# 1 "/home/peter/work/spineseg/test/PerSliceConnectedComponentImageFilterTest.cpp"
# 1 "<built-in>"
#define __cplusplus 1
#define __GXX_WEAK__ 1
#define __DEPRECATED 1
#define __EXCEPTIONS 1
#define __GXX_ABI_VERSION 102
#define __SIZE_TYPE__ unsigned int
#define __PTRDIFF_TYPE__ int
#define __WCHAR_TYPE__ long int
#define __WINT_TYPE__ unsigned int
#define __SCHAR_MAX__ 127
#define __SHRT_MAX__ 32767
#define __INT_MAX__ 2147483647
#define __LONG_MAX__ 2147483647L
#define __LONG_LONG_MAX__ 9223372036854775807LL
#define __WCHAR_MAX__ 2147483647
#define __CHAR_BIT__ 8
#define __FLT_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 __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 __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 __REGISTER_PREFIX__ 
#define __USER_LABEL_PREFIX__ 
#define __VERSION__ "3.3.5  (Gentoo Linux 3.3.5, ssp-3.3.2-3, pie-8.7.6.7)"
#define __OPTIMIZE__ 1
#define __STDC_HOSTED__ 1
#define __FINITE_MATH_ONLY__ 0
#define __STRICT_ANSI__ 1


#define __i386 1
#define __i386__ 1
#define __tune_i686__ 1
#define __tune_pentiumpro__ 1
#define __linux 1
#define __linux__ 1
#define __unix 1
#define __unix__ 1
#define __ELF__ 1
#define __gnu_linux__ 1
# 1 "<command line>"
#define __GNUG__ 3
#define __GNUC__ 3
#define __GNUC_MINOR__ 3
#define __GNUC_PATCHLEVEL__ 5
#define _GNU_SOURCE 1
# 1 "/home/peter/work/spineseg/test/PerSliceConnectedComponentImageFilterTest.cpp"
# 1 "../src/PerSliceConnectedComponentImageFilter.h" 1

#define PerSliceConnectedComponentImageFilter_h 


# 1 "../src/PerSliceImageFilter.h" 1

#define PerSliceImageFilter_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h"
#define __itkImageToImageFilter_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImage.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImage.h"
#define __itkImage_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
#define __itkImageBase_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
#define __itkDataObject_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkObject.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkObject.h"
#define __itkObject_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h"
#define __itkLightObject_h 





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iostream" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iostream" 3
#define _CPP_IOSTREAM 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iostream" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 1 3
# 32 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _CPP_CPPCONFIG 1


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/os_defines.h" 1 3
# 31 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/os_defines.h" 3
#define _GLIBCPP_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
# 110 "/usr/include/features.h" 3 4
#define __KERNEL_STRICT_NAMES 



#define __USE_ANSI 1
# 128 "/usr/include/features.h" 3 4
#define _ISOC99_SOURCE 1

#define _POSIX_SOURCE 1

#define _POSIX_C_SOURCE 199506L

#define _XOPEN_SOURCE 600

#define _XOPEN_SOURCE_EXTENDED 1

#define _LARGEFILE64_SOURCE 1

#define _BSD_SOURCE 1

#define _SVID_SOURCE 1
# 161 "/usr/include/features.h" 3 4
#define __USE_ISOC99 1
# 177 "/usr/include/features.h" 3 4
#define __USE_POSIX 1



#define __USE_POSIX2 1



#define __USE_POSIX199309 1



#define __USE_POSIX199506 1







#define __USE_XOPEN 1

#define __USE_XOPEN_EXTENDED 1
#define __USE_UNIX98 1

#define _LARGEFILE_SOURCE 1

#define __USE_XOPEN2K 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
# 216 "/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_GNU 1







#define __STDC_IEC_559__ 1
#define __STDC_IEC_559_COMPLEX__ 1


#define __STDC_ISO_10646__ 200009L
# 261 "/usr/include/features.h" 3 4
#define __GNU_LIBRARY__ 6



#define __GLIBC__ 2
#define __GLIBC_MINOR__ 3
# 276 "/usr/include/features.h" 3 4
#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))





#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
# 20 "/usr/include/sys/cdefs.h" 3 4
#define _SYS_CDEFS_H 1
# 44 "/usr/include/sys/cdefs.h" 3 4
#define __THROW throw ()



#define __P(args) args __THROW


#define __PMT(args) args
# 70 "/usr/include/sys/cdefs.h" 3 4
#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 }
# 104 "/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 __flexarr []
# 151 "/usr/include/sys/cdefs.h" 3 4
#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias))
#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
#define __ASMNAME2(prefix,cname) __STRING (prefix) cname
# 174 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_malloc__ __attribute__ ((__malloc__))
# 183 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_pure__ __attribute__ ((__pure__))
# 192 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_used__ __attribute__ ((__used__))
#define __attribute_noinline__ __attribute__ ((__noinline__))







#define __attribute_deprecated__ __attribute__ ((__deprecated__))
# 213 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x)))
# 223 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b)))
# 249 "/usr/include/sys/cdefs.h" 3 4
#define __restrict_arr 
# 297 "/usr/include/features.h" 2 3 4
# 311 "/usr/include/features.h" 3 4
#define __USE_EXTERN_INLINES 1







# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 3 4
#define __stub___kernel_cosl 
#define __stub___kernel_sinl 
#define __stub___kernel_tanl 
#define __stub_chflags 
#define __stub_fattach 
#define __stub_fchflags 
#define __stub_fdetach 
#define __stub_gtty 
#define __stub_lchmod 
#define __stub_lutimes 
#define __stub_revoke 
#define __stub_setlogin 
#define __stub_sstk 
#define __stub_stty 
# 320 "/usr/include/features.h" 2 3 4
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/os_defines.h" 2 3
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/os_defines.h" 3
#define __NO_STRING_INLINES 
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 2 3


#define __GLIBCPP__ 20040930


#define _GLIBCPP_NO_TEMPLATE_EXPORT 1
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_FULLY_COMPLIANT_HEADERS 1
# 59 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_EXTERN_TEMPLATE 1






#define _GLIBCPP_RESOLVE_LIB_DEFECTS 1


#define _GLIBCPP_AT_AT "@@"
# 94 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_FAST_MATH 0
# 105 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_HAVE_MMAP 1


#define _GLIBCPP_SUPPORTS_WEAK __GXX_WEAK__


#define _GLIBCPP_USE_LONG_LONG 1


#define _GLIBCPP_USE_C99 1


#define _GLIBCPP_USE_WCHAR_T 1


#define _GLIBCPP_MEM_LIMITS 1





#define _GLIBCPP_SYMVER 1






#define _GLIBCPP_ASM_SYMVER(cur,old,version) asm (".symver " #cur "," #old _GLIBCPP_AT_AT #version);






#define _GLIBCPP_HAVE_GTHR_DEFAULT 1


#define _GLIBCPP_HAVE_DRAND48 1


#define _GLIBCPP_HAVE_GETPAGESIZE 1


#define _GLIBCPP_HAVE_SETENV 1


#define _GLIBCPP_HAVE_SIGSETJMP 1


#define _GLIBCPP_HAVE_MBSTATE_T 1


#define _GLIBCPP_HAVE_MODFF 1


#define _GLIBCPP_HAVE_MODFL 1


#define _GLIBCPP_HAVE_EXPF 1


#define _GLIBCPP_HAVE_EXPL 1


#define _GLIBCPP_HAVE_HYPOTF 1


#define _GLIBCPP_HAVE_HYPOTL 1


#define _GLIBCPP_HAVE___BUILTIN_ABS 1


#define _GLIBCPP_HAVE___BUILTIN_LABS 1


#define _GLIBCPP_HAVE___BUILTIN_COS 1


#define _GLIBCPP_HAVE___BUILTIN_COSF 1


#define _GLIBCPP_HAVE___BUILTIN_COSL 1


#define _GLIBCPP_HAVE___BUILTIN_FABS 1


#define _GLIBCPP_HAVE___BUILTIN_FABSF 1


#define _GLIBCPP_HAVE___BUILTIN_FABSL 1


#define _GLIBCPP_HAVE___BUILTIN_SIN 1


#define _GLIBCPP_HAVE___BUILTIN_SINF 1


#define _GLIBCPP_HAVE___BUILTIN_SINL 1
# 218 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_HAVE_POLL 1


#define _GLIBCPP_HAVE_S_ISREG 1





#define _GLIBCPP_HAVE_LC_MESSAGES 1


#define _GLIBCPP_HAVE___SIGNBIT 1


#define _GLIBCPP_HAVE___SIGNBITF 1


#define _GLIBCPP_HAVE___SIGNBITL 1
# 428 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_HAVE_ACOSF 1


#define _GLIBCPP_HAVE_ACOSL 1


#define _GLIBCPP_HAVE_ASINF 1


#define _GLIBCPP_HAVE_ASINL 1


#define _GLIBCPP_HAVE_ATAN2F 1


#define _GLIBCPP_HAVE_ATAN2L 1


#define _GLIBCPP_HAVE_ATANF 1


#define _GLIBCPP_HAVE_ATANL 1


#define _GLIBCPP_HAVE_BTOWC 1


#define _GLIBCPP_HAVE_CEILF 1


#define _GLIBCPP_HAVE_CEILL 1


#define _GLIBCPP_HAVE_COPYSIGN 1


#define _GLIBCPP_HAVE_COPYSIGNF 1


#define _GLIBCPP_HAVE_COPYSIGNL 1


#define _GLIBCPP_HAVE_COSF 1


#define _GLIBCPP_HAVE_COSHF 1


#define _GLIBCPP_HAVE_COSHL 1


#define _GLIBCPP_HAVE_COSL 1


#define _GLIBCPP_HAVE_DRAND48 1


#define _GLIBCPP_HAVE_EXPF 1


#define _GLIBCPP_HAVE_EXPL 1


#define _GLIBCPP_HAVE_FABSF 1


#define _GLIBCPP_HAVE_FABSL 1


#define _GLIBCPP_HAVE_FGETWC 1


#define _GLIBCPP_HAVE_FGETWS 1


#define _GLIBCPP_HAVE_FINITE 1


#define _GLIBCPP_HAVE_FINITEF 1


#define _GLIBCPP_HAVE_FINITEL 1


#define _GLIBCPP_HAVE_FLOORF 1


#define _GLIBCPP_HAVE_FLOORL 1


#define _GLIBCPP_HAVE_FMODF 1


#define _GLIBCPP_HAVE_FMODL 1





#define _GLIBCPP_HAVE_FPUTWC 1


#define _GLIBCPP_HAVE_FPUTWS 1


#define _GLIBCPP_HAVE_FREXPF 1


#define _GLIBCPP_HAVE_FREXPL 1


#define _GLIBCPP_HAVE_FWIDE 1


#define _GLIBCPP_HAVE_FWPRINTF 1


#define _GLIBCPP_HAVE_FWSCANF 1


#define _GLIBCPP_HAVE_GETPAGESIZE 1


#define _GLIBCPP_HAVE_GETWC 1


#define _GLIBCPP_HAVE_GETWCHAR 1


#define _GLIBCPP_HAVE_HYPOT 1


#define _GLIBCPP_HAVE_HYPOTF 1


#define _GLIBCPP_HAVE_HYPOTL 1


#define _GLIBCPP_HAVE_ICONV 1


#define _GLIBCPP_HAVE_ICONV_CLOSE 1


#define _GLIBCPP_HAVE_ICONV_OPEN 1


#define _GLIBCPP_HAVE_ISATTY 1


#define _GLIBCPP_HAVE_ISINF 1


#define _GLIBCPP_HAVE_ISINFF 1


#define _GLIBCPP_HAVE_ISINFL 1


#define _GLIBCPP_HAVE_ISNAN 1


#define _GLIBCPP_HAVE_ISNANF 1


#define _GLIBCPP_HAVE_ISNANL 1


#define _GLIBCPP_HAVE_LDEXPF 1


#define _GLIBCPP_HAVE_LDEXPL 1


#define _GLIBCPP_HAVE_LOG10F 1


#define _GLIBCPP_HAVE_LOG10L 1


#define _GLIBCPP_HAVE_LOGF 1


#define _GLIBCPP_HAVE_LOGL 1


#define _GLIBCPP_HAVE_MBRLEN 1


#define _GLIBCPP_HAVE_MBRTOWC 1


#define _GLIBCPP_HAVE_MBSINIT 1


#define _GLIBCPP_HAVE_MBSRTOWCS 1


#define _GLIBCPP_HAVE_MODFF 1


#define _GLIBCPP_HAVE_MODFL 1


#define _GLIBCPP_HAVE_NAN 1


#define _GLIBCPP_HAVE_NL_LANGINFO 1


#define _GLIBCPP_HAVE_POWF 1


#define _GLIBCPP_HAVE_POWL 1


#define _GLIBCPP_HAVE_PUTWC 1


#define _GLIBCPP_HAVE_PUTWCHAR 1





#define _GLIBCPP_HAVE_SETENV 1


#define _GLIBCPP_HAVE_SINCOS 1


#define _GLIBCPP_HAVE_SINCOSF 1


#define _GLIBCPP_HAVE_SINCOSL 1


#define _GLIBCPP_HAVE_SINF 1


#define _GLIBCPP_HAVE_SINHF 1


#define _GLIBCPP_HAVE_SINHL 1


#define _GLIBCPP_HAVE_SINL 1


#define _GLIBCPP_HAVE_SQRTF 1


#define _GLIBCPP_HAVE_SQRTL 1


#define _GLIBCPP_HAVE_STRTOF 1


#define _GLIBCPP_HAVE_STRTOLD 1


#define _GLIBCPP_HAVE_SWPRINTF 1


#define _GLIBCPP_HAVE_SWSCANF 1


#define _GLIBCPP_HAVE_TANF 1


#define _GLIBCPP_HAVE_TANHF 1


#define _GLIBCPP_HAVE_TANHL 1


#define _GLIBCPP_HAVE_TANL 1


#define _GLIBCPP_HAVE_UNGETWC 1


#define _GLIBCPP_HAVE_VFWPRINTF 1


#define _GLIBCPP_HAVE_VFWSCANF 1


#define _GLIBCPP_HAVE_VSWPRINTF 1


#define _GLIBCPP_HAVE_VSWSCANF 1


#define _GLIBCPP_HAVE_VWPRINTF 1


#define _GLIBCPP_HAVE_VWSCANF 1


#define _GLIBCPP_HAVE_WCRTOMB 1


#define _GLIBCPP_HAVE_WCSCAT 1


#define _GLIBCPP_HAVE_WCSCHR 1


#define _GLIBCPP_HAVE_WCSCMP 1


#define _GLIBCPP_HAVE_WCSCOLL 1


#define _GLIBCPP_HAVE_WCSCPY 1


#define _GLIBCPP_HAVE_WCSCSPN 1


#define _GLIBCPP_HAVE_WCSFTIME 1


#define _GLIBCPP_HAVE_WCSLEN 1


#define _GLIBCPP_HAVE_WCSNCAT 1


#define _GLIBCPP_HAVE_WCSNCMP 1


#define _GLIBCPP_HAVE_WCSNCPY 1


#define _GLIBCPP_HAVE_WCSPBRK 1


#define _GLIBCPP_HAVE_WCSRCHR 1


#define _GLIBCPP_HAVE_WCSRTOMBS 1


#define _GLIBCPP_HAVE_WCSSPN 1


#define _GLIBCPP_HAVE_WCSSTR 1


#define _GLIBCPP_HAVE_WCSTOD 1


#define _GLIBCPP_HAVE_WCSTOF 1


#define _GLIBCPP_HAVE_WCSTOK 1


#define _GLIBCPP_HAVE_WCSTOL 1


#define _GLIBCPP_HAVE_WCSTOUL 1


#define _GLIBCPP_HAVE_WCSXFRM 1


#define _GLIBCPP_HAVE_WCTOB 1


#define _GLIBCPP_HAVE_WMEMCHR 1


#define _GLIBCPP_HAVE_WMEMCMP 1


#define _GLIBCPP_HAVE_WMEMCPY 1


#define _GLIBCPP_HAVE_WMEMMOVE 1


#define _GLIBCPP_HAVE_WMEMSET 1


#define _GLIBCPP_HAVE_WPRINTF 1


#define _GLIBCPP_HAVE_WSCANF 1


#define _GLIBCPP_HAVE_ENDIAN_H 1


#define _GLIBCPP_HAVE_FLOAT_H 1





#define _GLIBCPP_HAVE_GCONV_H 1





#define _GLIBCPP_HAVE_INTTYPES_H 1


#define _GLIBCPP_HAVE_LOCALE_H 1
# 851 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_HAVE_STDLIB_H 1


#define _GLIBCPP_HAVE_STRING_H 1





#define _GLIBCPP_HAVE_SYS_IOCTL_H 1
# 869 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
#define _GLIBCPP_HAVE_SYS_RESOURCE_H 1


#define _GLIBCPP_HAVE_SYS_STAT_H 1


#define _GLIBCPP_HAVE_SYS_TIME_H 1


#define _GLIBCPP_HAVE_SYS_TYPES_H 1


#define _GLIBCPP_HAVE_UNISTD_H 1


#define _GLIBCPP_HAVE_WCHAR_H 1


#define _GLIBCPP_HAVE_WCTYPE_H 1


#define _GLIBCPP_HAVE_LIBM 1


#define _GLIBCPP_PACKAGE "libstdc++"


#define _GLIBCPP_VERSION "3.3.5"





#define _GLIBCPP_HAVE_SIGSETJMP 1


#define _GLIBCPP_HAVE_MEMLIMIT_DATA 1


#define _GLIBCPP_HAVE_MEMLIMIT_RSS 1


#define _GLIBCPP_HAVE_MEMLIMIT_VMEM 0


#define _GLIBCPP_HAVE_MEMLIMIT_AS 1
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iostream" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
#define _CPP_OSTREAM 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 3
#define _CPP_IOS 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 3
#define _CPP_IOSFWD 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 1 3
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 3
#define _CPP_BITS_C_LOCALE_H 1

       
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/clocale" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/clocale" 3
#define _CPP_CLOCALE 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 399 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL
# 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;
# 119 "/usr/include/locale.h" 3 4
};





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


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


# 146 "/usr/include/locale.h" 3 4
# 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;
# 147 "/usr/include/locale.h" 2 3 4

typedef __locale_t locale_t;





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



}
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/clocale" 2 3





namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/include/langinfo.h" 1 3 4
# 21 "/usr/include/langinfo.h" 3 4
#define _LANGINFO_H 1


# 1 "/usr/include/nl_types.h" 1 3 4
# 20 "/usr/include/nl_types.h" 3 4
#define _NL_TYPES_H 1




#define NL_SETD 1


#define NL_CAT_LOCALE 1


extern "C" {


typedef void *nl_catd;


typedef int nl_item;





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



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


extern int catclose (nl_catd __catalog) throw ();

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

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


extern "C" {





#define _NL_ITEM(category,index) (((category) << 16) | (index))


#define _NL_ITEM_CATEGORY(item) ((int) (item) >> 16)
#define _NL_ITEM_INDEX(item) ((int) (item) & 0xffff)



enum
{



  ABDAY_1 = (((__LC_TIME) << 16) | (0)),
#define ABDAY_1 ABDAY_1
  ABDAY_2,
#define ABDAY_2 ABDAY_2
  ABDAY_3,
#define ABDAY_3 ABDAY_3
  ABDAY_4,
#define ABDAY_4 ABDAY_4
  ABDAY_5,
#define ABDAY_5 ABDAY_5
  ABDAY_6,
#define ABDAY_6 ABDAY_6
  ABDAY_7,
#define ABDAY_7 ABDAY_7


  DAY_1,
#define DAY_1 DAY_1
  DAY_2,
#define DAY_2 DAY_2
  DAY_3,
#define DAY_3 DAY_3
  DAY_4,
#define DAY_4 DAY_4
  DAY_5,
#define DAY_5 DAY_5
  DAY_6,
#define DAY_6 DAY_6
  DAY_7,
#define DAY_7 DAY_7


  ABMON_1,
#define ABMON_1 ABMON_1
  ABMON_2,
#define ABMON_2 ABMON_2
  ABMON_3,
#define ABMON_3 ABMON_3
  ABMON_4,
#define ABMON_4 ABMON_4
  ABMON_5,
#define ABMON_5 ABMON_5
  ABMON_6,
#define ABMON_6 ABMON_6
  ABMON_7,
#define ABMON_7 ABMON_7
  ABMON_8,
#define ABMON_8 ABMON_8
  ABMON_9,
#define ABMON_9 ABMON_9
  ABMON_10,
#define ABMON_10 ABMON_10
  ABMON_11,
#define ABMON_11 ABMON_11
  ABMON_12,
#define ABMON_12 ABMON_12


  MON_1,
#define MON_1 MON_1
  MON_2,
#define MON_2 MON_2
  MON_3,
#define MON_3 MON_3
  MON_4,
#define MON_4 MON_4
  MON_5,
#define MON_5 MON_5
  MON_6,
#define MON_6 MON_6
  MON_7,
#define MON_7 MON_7
  MON_8,
#define MON_8 MON_8
  MON_9,
#define MON_9 MON_9
  MON_10,
#define MON_10 MON_10
  MON_11,
#define MON_11 MON_11
  MON_12,
#define MON_12 MON_12

  AM_STR,
#define AM_STR AM_STR
  PM_STR,
#define PM_STR PM_STR

  D_T_FMT,
#define D_T_FMT D_T_FMT
  D_FMT,
#define D_FMT D_FMT
  T_FMT,
#define T_FMT T_FMT
  T_FMT_AMPM,
#define T_FMT_AMPM T_FMT_AMPM

  ERA,
#define ERA ERA
  __ERA_YEAR,

#define ERA_YEAR __ERA_YEAR

  ERA_D_FMT,
#define ERA_D_FMT ERA_D_FMT
  ALT_DIGITS,
#define ALT_DIGITS ALT_DIGITS
  ERA_D_T_FMT,
#define ERA_D_T_FMT ERA_D_T_FMT
  ERA_T_FMT,
#define ERA_T_FMT ERA_T_FMT

  _NL_TIME_ERA_NUM_ENTRIES,
  _NL_TIME_ERA_ENTRIES,

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


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


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


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

  _NL_WAM_STR,
  _NL_WPM_STR,

  _NL_WD_T_FMT,
  _NL_WD_FMT,
  _NL_WT_FMT,
  _NL_WT_FMT_AMPM,

  _NL_WERA_YEAR,
  _NL_WERA_D_FMT,
  _NL_WALT_DIGITS,
  _NL_WERA_D_T_FMT,
  _NL_WERA_T_FMT,

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

  _DATE_FMT,
#define _DATE_FMT _DATE_FMT
  _NL_W_DATE_FMT,

  _NL_TIME_CODESET,

  _NL_NUM_LC_TIME,




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




  _NL_CTYPE_CLASS = (((__LC_CTYPE) << 16) | (0)),
  _NL_CTYPE_TOUPPER,
  _NL_CTYPE_GAP1,
  _NL_CTYPE_TOLOWER,
  _NL_CTYPE_GAP2,
  _NL_CTYPE_CLASS32,
  _NL_CTYPE_GAP3,
  _NL_CTYPE_GAP4,
  _NL_CTYPE_GAP5,
  _NL_CTYPE_GAP6,
  _NL_CTYPE_CLASS_NAMES,
  _NL_CTYPE_MAP_NAMES,
  _NL_CTYPE_WIDTH,
  _NL_CTYPE_MB_CUR_MAX,
  _NL_CTYPE_CODESET_NAME,
  CODESET = _NL_CTYPE_CODESET_NAME,
#define CODESET CODESET
  _NL_CTYPE_TOUPPER32,
  _NL_CTYPE_TOLOWER32,
  _NL_CTYPE_CLASS_OFFSET,
  _NL_CTYPE_MAP_OFFSET,
  _NL_CTYPE_INDIGITS_MB_LEN,
  _NL_CTYPE_INDIGITS0_MB,
  _NL_CTYPE_INDIGITS1_MB,
  _NL_CTYPE_INDIGITS2_MB,
  _NL_CTYPE_INDIGITS3_MB,
  _NL_CTYPE_INDIGITS4_MB,
  _NL_CTYPE_INDIGITS5_MB,
  _NL_CTYPE_INDIGITS6_MB,
  _NL_CTYPE_INDIGITS7_MB,
  _NL_CTYPE_INDIGITS8_MB,
  _NL_CTYPE_INDIGITS9_MB,
  _NL_CTYPE_INDIGITS_WC_LEN,
  _NL_CTYPE_INDIGITS0_WC,
  _NL_CTYPE_INDIGITS1_WC,
  _NL_CTYPE_INDIGITS2_WC,
  _NL_CTYPE_INDIGITS3_WC,
  _NL_CTYPE_INDIGITS4_WC,
  _NL_CTYPE_INDIGITS5_WC,
  _NL_CTYPE_INDIGITS6_WC,
  _NL_CTYPE_INDIGITS7_WC,
  _NL_CTYPE_INDIGITS8_WC,
  _NL_CTYPE_INDIGITS9_WC,
  _NL_CTYPE_OUTDIGIT0_MB,
  _NL_CTYPE_OUTDIGIT1_MB,
  _NL_CTYPE_OUTDIGIT2_MB,
  _NL_CTYPE_OUTDIGIT3_MB,
  _NL_CTYPE_OUTDIGIT4_MB,
  _NL_CTYPE_OUTDIGIT5_MB,
  _NL_CTYPE_OUTDIGIT6_MB,
  _NL_CTYPE_OUTDIGIT7_MB,
  _NL_CTYPE_OUTDIGIT8_MB,
  _NL_CTYPE_OUTDIGIT9_MB,
  _NL_CTYPE_OUTDIGIT0_WC,
  _NL_CTYPE_OUTDIGIT1_WC,
  _NL_CTYPE_OUTDIGIT2_WC,
  _NL_CTYPE_OUTDIGIT3_WC,
  _NL_CTYPE_OUTDIGIT4_WC,
  _NL_CTYPE_OUTDIGIT5_WC,
  _NL_CTYPE_OUTDIGIT6_WC,
  _NL_CTYPE_OUTDIGIT7_WC,
  _NL_CTYPE_OUTDIGIT8_WC,
  _NL_CTYPE_OUTDIGIT9_WC,
  _NL_CTYPE_TRANSLIT_TAB_SIZE,
  _NL_CTYPE_TRANSLIT_FROM_IDX,
  _NL_CTYPE_TRANSLIT_FROM_TBL,
  _NL_CTYPE_TRANSLIT_TO_IDX,
  _NL_CTYPE_TRANSLIT_TO_TBL,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING,
  _NL_CTYPE_TRANSLIT_IGNORE_LEN,
  _NL_CTYPE_TRANSLIT_IGNORE,
  _NL_CTYPE_MAP_TO_NONASCII,
  _NL_CTYPE_EXTRA_MAP_1,
  _NL_CTYPE_EXTRA_MAP_2,
  _NL_CTYPE_EXTRA_MAP_3,
  _NL_CTYPE_EXTRA_MAP_4,
  _NL_CTYPE_EXTRA_MAP_5,
  _NL_CTYPE_EXTRA_MAP_6,
  _NL_CTYPE_EXTRA_MAP_7,
  _NL_CTYPE_EXTRA_MAP_8,
  _NL_CTYPE_EXTRA_MAP_9,
  _NL_CTYPE_EXTRA_MAP_10,
  _NL_CTYPE_EXTRA_MAP_11,
  _NL_CTYPE_EXTRA_MAP_12,
  _NL_CTYPE_EXTRA_MAP_13,
  _NL_CTYPE_EXTRA_MAP_14,
  _NL_NUM_LC_CTYPE,




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

#define INT_CURR_SYMBOL __INT_CURR_SYMBOL

  __CURRENCY_SYMBOL,

#define CURRENCY_SYMBOL __CURRENCY_SYMBOL

  __MON_DECIMAL_POINT,

#define MON_DECIMAL_POINT __MON_DECIMAL_POINT

  __MON_THOUSANDS_SEP,

#define MON_THOUSANDS_SEP __MON_THOUSANDS_SEP

  __MON_GROUPING,

#define MON_GROUPING __MON_GROUPING

  __POSITIVE_SIGN,

#define POSITIVE_SIGN __POSITIVE_SIGN

  __NEGATIVE_SIGN,

#define NEGATIVE_SIGN __NEGATIVE_SIGN

  __INT_FRAC_DIGITS,

#define INT_FRAC_DIGITS __INT_FRAC_DIGITS

  __FRAC_DIGITS,

#define FRAC_DIGITS __FRAC_DIGITS

  __P_CS_PRECEDES,

#define P_CS_PRECEDES __P_CS_PRECEDES

  __P_SEP_BY_SPACE,

#define P_SEP_BY_SPACE __P_SEP_BY_SPACE

  __N_CS_PRECEDES,

#define N_CS_PRECEDES __N_CS_PRECEDES

  __N_SEP_BY_SPACE,

#define N_SEP_BY_SPACE __N_SEP_BY_SPACE

  __P_SIGN_POSN,

#define P_SIGN_POSN __P_SIGN_POSN

  __N_SIGN_POSN,

#define N_SIGN_POSN __N_SIGN_POSN

  _NL_MONETARY_CRNCYSTR,
#define CRNCYSTR _NL_MONETARY_CRNCYSTR
  __INT_P_CS_PRECEDES,

#define INT_P_CS_PRECEDES __INT_P_CS_PRECEDES

  __INT_P_SEP_BY_SPACE,

#define INT_P_SEP_BY_SPACE __INT_P_SEP_BY_SPACE

  __INT_N_CS_PRECEDES,

#define INT_N_CS_PRECEDES __INT_N_CS_PRECEDES

  __INT_N_SEP_BY_SPACE,

#define INT_N_SEP_BY_SPACE __INT_N_SEP_BY_SPACE

  __INT_P_SIGN_POSN,

#define INT_P_SIGN_POSN __INT_P_SIGN_POSN

  __INT_N_SIGN_POSN,

#define INT_N_SIGN_POSN __INT_N_SIGN_POSN

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



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

#define DECIMAL_POINT __DECIMAL_POINT

  RADIXCHAR = __DECIMAL_POINT,
#define RADIXCHAR RADIXCHAR
  __THOUSANDS_SEP,

#define THOUSANDS_SEP __THOUSANDS_SEP

  THOUSEP = __THOUSANDS_SEP,
#define THOUSEP THOUSEP
  __GROUPING,

#define GROUPING __GROUPING

  _NL_NUMERIC_DECIMAL_POINT_WC,
  _NL_NUMERIC_THOUSANDS_SEP_WC,
  _NL_NUMERIC_CODESET,
  _NL_NUM_LC_NUMERIC,

  __YESEXPR = (((__LC_MESSAGES) << 16) | (0)),
#define YESEXPR __YESEXPR
  __NOEXPR,
#define NOEXPR __NOEXPR
  __YESSTR,

#define YESSTR __YESSTR

  __NOSTR,

#define NOSTR __NOSTR

  _NL_MESSAGES_CODESET,
  _NL_NUM_LC_MESSAGES,

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

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

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

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

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

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


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


}
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/include/iconv.h" 1 3 4
# 20 "/usr/include/iconv.h" 3 4
#define _ICONV_H 1


#define __need_size_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 188 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/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 unsigned int size_t;
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 25 "/usr/include/iconv.h" 2 3 4


extern "C" {


typedef void *iconv_t;







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




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





extern int iconv_close (iconv_t __cd);

}
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 2 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 ();



extern char *dgettext (__const char *__domainname, __const char *__msgid)
     throw ();
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 ();
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 ();
# 120 "/usr/include/libintl.h" 3 4
}
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 2 3

#define _GLIBCPP_C_LOCALE_GNU 1

#define _GLIBCPP_NUM_CATEGORIES 6


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


namespace std
{
  typedef __locale_t __c_locale;





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

                     _Tv __v, const __c_locale& __cloc, int __prec = -1)
    {
      __c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 82 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 3
      int __ret;

      if (__prec >= 0)
        __ret = snprintf(__out, __size, __fmt, __prec, __v);
      else
        __ret = snprintf(__out, __size, __fmt, __v);
# 96 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++locale.h" 3
      __gnu_cxx::__uselocale(__old);




      return __ret;
    }
}
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cctype" 1 3
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cctype" 3
#define _CPP_CCTYPE 1

       
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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
# 19 "/usr/include/bits/wordsize.h" 3 4
#define __WORDSIZE 32
# 29 "/usr/include/bits/types.h" 2 3 4

#define __need_size_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 32 "/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;




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







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 102 "/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

#define __SQUAD_TYPE long long int
#define __UQUAD_TYPE unsigned long long int
#define __SWORD_TYPE int
#define __UWORD_TYPE unsigned int
#define __SLONG32_TYPE long int
#define __ULONG32_TYPE unsigned long int
#define __S64_TYPE __quad_t
#define __U64_TYPE __u_quad_t
# 129 "/usr/include/bits/types.h" 3 4
# 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 __S32_TYPE
#define __BLKSIZE_T_TYPE __SLONGWORD_TYPE
#define __FSID_T_TYPE struct { int __val[2]; }
#define __SSIZE_T_TYPE __SWORD_TYPE


#define __FD_SETSIZE 1024
# 130 "/usr/include/bits/types.h" 2 3 4



#define __STD_TYPE __extension__ typedef


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

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef int __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef long long int __blkcnt64_t;


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


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

__extension__ typedef int __ssize_t;



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


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;


#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
# 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)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
     __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
}
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cctype" 2 3
# 66 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cctype" 3
namespace std
{
  using ::isalnum;
  using ::isalpha;
  using ::iscntrl;
  using ::isdigit;
  using ::isgraph;
  using ::islower;
  using ::isprint;
  using ::ispunct;
  using ::isspace;
  using ::isupper;
  using ::isxdigit;
  using ::tolower;
  using ::toupper;
}
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stringfwd.h" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stringfwd.h" 3
#define _CPP_BITS_STRINGFWD_H 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stringfwd.h" 3



namespace std
{
  template<typename _Alloc>
    class allocator;

  template<class _CharT>
    struct char_traits;

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

  template<> struct char_traits<char>;

  typedef basic_string<char> string;


  template<> struct char_traits<wchar_t>;

  typedef basic_string<wchar_t> wstring;

}
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/fpos.h" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/fpos.h" 3
#define _CPP_BITS_FPOS_H 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/fpos.h" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++io.h" 1 3
# 33 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++io.h" 3
#define _CPP_IO_STDIO_H 1

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 3
#define _CPP_CSTDIO 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstddef" 1 3
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstddef" 3
#define _CPP_CSTDDEF 1

       
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstddef" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define _STDDEF_H 
#define _STDDEF_H_ 

#define _ANSI_STDDEF_H 

#define __STDDEF_H__ 
# 140 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/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 int ptrdiff_t;
# 264 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/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 
# 291 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef _BSD_WCHAR_T_
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstddef" 2 3

namespace std
{
  using ::ptrdiff_t;
  using ::size_t;
}
# 51 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 2 3

# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
#define _STDIO_H 1


extern "C" {

#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 35 "/usr/include/stdio.h" 2 3 4


#define __need_FILE 
#define __need___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



#define _STDIO_USES_IOSTREAM 

# 1 "/usr/include/libio.h" 1 3 4
# 30 "/usr/include/libio.h" 3 4
#define _IO_STDIO_H 

# 1 "/usr/include/_G_config.h" 1 3 4




#define _G_config_h 1




#define __need_size_t 
#define __need_wchar_t 
#define __need_wint_t 
#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 344 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wchar_t




#define _WINT_T 




typedef unsigned int wint_t;

#undef __need_wint_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 15 "/usr/include/_G_config.h" 2 3 4
# 23 "/usr/include/_G_config.h" 3 4
#define __need_mbstate_t 
# 1 "/usr/include/wchar.h" 1 3 4
# 47 "/usr/include/wchar.h" 3 4
#define __need_wint_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 356 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wint_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 49 "/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 (-2147483647l - 1l)
#define __WCHAR_MAX (2147483647l)
# 51 "/usr/include/wchar.h" 2 3 4
# 74 "/usr/include/wchar.h" 3 4
#define __mbstate_t_defined 1

typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;

#undef __need_mbstate_t
# 25 "/usr/include/_G_config.h" 2 3 4
#define _G_size_t size_t
typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
#define _G_ssize_t __ssize_t
#define _G_off_t __off_t
#define _G_off64_t __off64_t
#define _G_pid_t __pid_t
#define _G_uid_t __uid_t
#define _G_wchar_t wchar_t
#define _G_wint_t wint_t
#define _G_stat64 stat64
# 1 "/usr/include/gconv.h" 1 3 4
# 24 "/usr/include/gconv.h" 3 4
#define _GCONV_H 1


#define __need_mbstate_t 
# 1 "/usr/include/wchar.h" 1 3 4
# 47 "/usr/include/wchar.h" 3 4
#define __need_wint_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 356 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wint_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 49 "/usr/include/wchar.h" 2 3 4
# 86 "/usr/include/wchar.h" 3 4
#undef __need_mbstate_t
# 29 "/usr/include/gconv.h" 2 3 4
#define __need_size_t 
#define __need_wchar_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 344 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wchar_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 32 "/usr/include/gconv.h" 2 3 4


#define __UNKNOWN_10646_CHAR ((wchar_t) 0xfffd)


enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
                            __const unsigned char **, __const unsigned char *,
                            unsigned char **, size_t *, int, int);


typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
                                  struct __gconv_step_data *, void *,
                                  __const unsigned char *,
                                  __const unsigned char **,
                                  __const unsigned char *, unsigned char **,
                                  size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
                                          __const unsigned char *,
                                          unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
                                        size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_btowc_fct __btowc_fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3 4
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));

#define _G_HAVE_BOOL 1



#define _G_HAVE_ATEXIT 1
#define _G_HAVE_SYS_CDEFS 1
#define _G_HAVE_SYS_WAIT 1
#define _G_NEED_STDARG_H 1
#define _G_va_list __gnuc_va_list

#define _G_HAVE_PRINTF_FP 1
#define _G_HAVE_MMAP 1
#define _G_HAVE_LONG_DOUBLE_IO 1
#define _G_HAVE_IO_FILE_OPEN 1
#define _G_HAVE_IO_GETLINE_INFO 1

#define _G_IO_IO_FILE_VERSION 0x20001

#define _G_OPEN64 __open64
#define _G_LSEEK64 __lseek64
#define _G_MMAP64 __mmap64
#define _G_FSTAT64(fd,buf) __fxstat64 (_STAT_VER, fd, buf)


#define _G_HAVE_ST_BLKSIZE defined (_STATBUF_ST_BLKSIZE)

#define _G_BUFSIZ 8192


#define _G_NAMES_HAVE_UNDERSCORE 0
#define _G_VTABLE_LABEL_HAS_LENGTH 1
#define _G_USING_THUNKS 1
#define _G_VTABLE_LABEL_PREFIX "__vt_"
#define _G_VTABLE_LABEL_PREFIX_ID __vt_



#define _G_ARGS(ARGLIST) ARGLIST
# 33 "/usr/include/libio.h" 2 3 4

#define _IO_pos_t _G_fpos_t
#define _IO_fpos_t _G_fpos_t
#define _IO_fpos64_t _G_fpos64_t
#define _IO_size_t _G_size_t
#define _IO_ssize_t _G_ssize_t
#define _IO_off_t _G_off_t
#define _IO_off64_t _G_off64_t
#define _IO_pid_t _G_pid_t
#define _IO_uid_t _G_uid_t
#define _IO_iconv_t _G_iconv_t
#define _IO_HAVE_SYS_WAIT _G_HAVE_SYS_WAIT
#define _IO_HAVE_ST_BLKSIZE _G_HAVE_ST_BLKSIZE
#define _IO_BUFSIZ _G_BUFSIZ
#define _IO_va_list _G_va_list
#define _IO_wint_t _G_wint_t



#define __need___va_list 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stdarg.h" 1 3 4
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stdarg.h" 3 4
#undef __need___va_list




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

#undef _IO_va_list
#define _IO_va_list __gnuc_va_list
# 76 "/usr/include/libio.h" 3 4
#define _PARAMS(protos) __P(protos)







#define _IO_UNIFIED_JUMPTABLES 1





#define EOF (-1)
# 105 "/usr/include/libio.h" 3 4
#define _IOS_INPUT 1
#define _IOS_OUTPUT 2
#define _IOS_ATEND 4
#define _IOS_APPEND 8
#define _IOS_TRUNC 16
#define _IOS_NOCREATE 32
#define _IOS_NOREPLACE 64
#define _IOS_BIN 128







#define _IO_MAGIC 0xFBAD0000
#define _OLD_STDIO_MAGIC 0xFABC0000
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4
#define _IO_NO_WRITES 8
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40
#define _IO_LINKED 0x80
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
#define _IO_BAD_SEEN 0x4000
#define _IO_USER_LOCK 0x8000

#define _IO_FLAGS2_MMAP 1
#define _IO_FLAGS2_NOTCANCEL 2


#define _IO_SKIPWS 01
#define _IO_LEFT 02
#define _IO_RIGHT 04
#define _IO_INTERNAL 010
#define _IO_DEC 020
#define _IO_OCT 040
#define _IO_HEX 0100
#define _IO_SHOWBASE 0200
#define _IO_SHOWPOINT 0400
#define _IO_UPPERCASE 01000
#define _IO_SHOWPOS 02000
#define _IO_SCIENTIFIC 04000
#define _IO_FIXED 010000
#define _IO_UNITBUF 020000
#define _IO_STDIO 040000
#define _IO_DONT_CLOSE 0100000
#define _IO_BOOLALPHA 0200000


struct _IO_jump_t; struct _IO_FILE;
# 173 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





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



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


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};




struct _IO_codecvt
{
  void (*__codecvt_destr) (struct _IO_codecvt *);
  enum __codecvt_result (*__codecvt_do_out) (struct _IO_codecvt *,
                                             __mbstate_t *,
                                             const wchar_t *,
                                             const wchar_t *,
                                             const wchar_t **, char *,
                                             char *, char **);
  enum __codecvt_result (*__codecvt_do_unshift) (struct _IO_codecvt *,
                                                 __mbstate_t *, char *,
                                                 char *, char **);
  enum __codecvt_result (*__codecvt_do_in) (struct _IO_codecvt *,
                                            __mbstate_t *,
                                            const char *, const char *,
                                            const char **, wchar_t *,
                                            wchar_t *, wchar_t **);
  int (*__codecvt_do_encoding) (struct _IO_codecvt *);
  int (*__codecvt_do_always_noconv) (struct _IO_codecvt *);
  int (*__codecvt_do_length) (struct _IO_codecvt *, __mbstate_t *,
                              const char *, const char *, size_t);
  int (*__codecvt_do_max_length) (struct _IO_codecvt *);

  _G_iconv_t __cd_in;
  _G_iconv_t __cd_out;
};


struct _IO_wide_data
{
  wchar_t *_IO_read_ptr;
  wchar_t *_IO_read_end;
  wchar_t *_IO_read_base;
  wchar_t *_IO_write_base;
  wchar_t *_IO_write_ptr;
  wchar_t *_IO_write_end;
  wchar_t *_IO_buf_base;
  wchar_t *_IO_buf_end;

  wchar_t *_IO_save_base;
  wchar_t *_IO_backup_base;

  wchar_t *_IO_save_end;

  __mbstate_t _IO_state;
  __mbstate_t _IO_last_state;
  struct _IO_codecvt _codecvt;

  wchar_t _shortbuf[1];

  const struct _IO_jump_t *_wide_vtable;
};


struct _IO_FILE {
  int _flags;
#define _IO_file_flags _flags



  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;

#define __HAVE_COLUMN 

  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 312 "/usr/include/libio.h" 3 4
  __off64_t _offset;


  struct _IO_codecvt *_codecvt;
  struct _IO_wide_data *_wide_data;




  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};





struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;

#define _IO_stdin ((_IO_FILE*)(&_IO_2_1_stdin_))
#define _IO_stdout ((_IO_FILE*)(&_IO_2_1_stdout_))
#define _IO_stderr ((_IO_FILE*)(&_IO_2_1_stderr_))
# 351 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
                                 size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);




typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;


typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;

struct _IO_cookie_file;


extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
                             void *__cookie, _IO_cookie_io_functions_t __fns);




extern "C" {


extern int __underflow (_IO_FILE *) throw ();
extern int __uflow (_IO_FILE *) throw ();
extern int __overflow (_IO_FILE *, int) throw ();
extern wint_t __wunderflow (_IO_FILE *) throw ();
extern wint_t __wuflow (_IO_FILE *) throw ();
extern wint_t __woverflow (_IO_FILE *, wint_t) throw ();


#define _IO_BE(expr,res) __builtin_expect (expr, res)




#define _IO_getc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)


#define _IO_peekc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) && __underflow (_fp) == EOF ? EOF : *(unsigned char *) (_fp)->_IO_read_ptr)



#define _IO_putc_unlocked(_ch,_fp) (_IO_BE ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end, 0) ? __overflow (_fp, (unsigned char) (_ch)) : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))




#define _IO_getwc_unlocked(_fp) (_IO_BE ((_fp)->_wide_data->_IO_read_ptr >= (_fp)->_wide_data->_IO_read_end, 0) ? __wuflow (_fp) : (_IO_wint_t) *(_fp)->_wide_data->_IO_read_ptr++)



#define _IO_putwc_unlocked(_wch,_fp) (_IO_BE ((_fp)->_wide_data->_IO_write_ptr >= (_fp)->_wide_data->_IO_write_end, 0) ? __woverflow (_fp, _wch) : (_IO_wint_t) (*(_fp)->_wide_data->_IO_write_ptr++ = (_wch)))





#define _IO_feof_unlocked(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
#define _IO_ferror_unlocked(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)

extern int _IO_getc (_IO_FILE *__fp) throw ();
extern int _IO_putc (int __c, _IO_FILE *__fp) throw ();
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();

extern int _IO_peekc_locked (_IO_FILE *__fp) throw ();


#define _IO_PENDING_OUTPUT_COUNT(_fp) ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)


extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 463 "/usr/include/libio.h" 3 4
#define _IO_peekc(_fp) _IO_peekc_unlocked (_fp)
#define _IO_flockfile(_fp) 
#define _IO_funlockfile(_fp) 
#define _IO_ftrylockfile(_fp) 
#define _IO_cleanup_region_start(_fct,_fp) 
#define _IO_cleanup_region_end(_Doit) 


extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
                        __gnuc_va_list, int *__restrict) throw ();
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
                         __gnuc_va_list) throw ();
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) throw ();
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) throw ();

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) throw ();
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) throw ();

extern void _IO_free_backup_area (_IO_FILE *) throw ();


extern wint_t _IO_getwc (_IO_FILE *__fp) throw ();
extern wint_t _IO_putwc (wchar_t __wc, _IO_FILE *__fp) throw ();
extern int _IO_fwide (_IO_FILE *__fp, int __mode) throw ();
# 500 "/usr/include/libio.h" 3 4
#define _IO_fwide_maybe_incompatible (0)



#define _IO_fwide(__fp,__mode) ({ int __result = (__mode); if (__result < 0 && ! _IO_fwide_maybe_incompatible) { if ((__fp)->_mode == 0) (__fp)->_mode = -1; __result = (__fp)->_mode; } else if (__builtin_constant_p (__mode) && (__mode) == 0) __result = _IO_fwide_maybe_incompatible ? -1 : (__fp)->_mode; else __result = _IO_fwide (__fp, __result); __result; })
# 520 "/usr/include/libio.h" 3 4
extern int _IO_vfwscanf (_IO_FILE * __restrict, const wchar_t * __restrict,
                         __gnuc_va_list, int *__restrict) throw ();
extern int _IO_vfwprintf (_IO_FILE *__restrict, const wchar_t *__restrict,
                          __gnuc_va_list) throw ();
extern __ssize_t _IO_wpadn (_IO_FILE *, wint_t, __ssize_t) throw ();
extern void _IO_free_wbackup_area (_IO_FILE *) throw ();



}
# 73 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
#define _VA_LIST_DEFINED 









typedef _G_fpos_t fpos_t;





typedef _G_fpos64_t fpos64_t;



#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2




#define BUFSIZ _IO_BUFSIZ
# 118 "/usr/include/stdio.h" 3 4
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2




#define P_tmpdir "/tmp"
# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 24 "/usr/include/bits/stdio_lim.h" 3 4
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096


#define L_ctermid 9
#define L_cuserid 9





#define FOPEN_MAX 16
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;

#define stdin stdin
#define stdout stdout
#define stderr stderr



extern int remove (__const char *__filename) throw ();

extern int rename (__const char *__old, __const char *__new) throw ();









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



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





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








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

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









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




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


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




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





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


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




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






extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
                    int __modes, size_t __n) throw ();





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
                       size_t __size) throw ();


extern void setlinebuf (FILE *__stream) throw ();








extern int fprintf (FILE *__restrict __stream,
                    __const char *__restrict __format, ...);




extern int printf (__const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
                    __const char *__restrict __format, ...) throw ();





extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) throw ();





extern int snprintf (char *__restrict __s, size_t __maxlen,
                     __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
                      __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));






extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
                      __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern int __asprintf (char **__restrict __ptr,
                       __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int asprintf (char **__restrict __ptr,
                     __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));







extern int vdprintf (int __fd, __const char *__restrict __fmt,
                     __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








extern int fscanf (FILE *__restrict __stream,
                   __const char *__restrict __format, ...);




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

extern int sscanf (__const char *__restrict __s,
                   __const char *__restrict __format, ...) throw ();








extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
                    __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0)));





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


extern int vsscanf (__const char *__restrict __s,
                    __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));









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





extern int getchar (void);




#define getc(_fp) _IO_getc (_fp)






extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 465 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);




#define putc(_ch,_fp) _IO_putc (_ch, _fp)
# 498 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);






extern char *gets (char *__s);

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







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








extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
                     size_t __n, FILE *__restrict __stream);




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
                      size_t __n, FILE *__restrict __s);

# 620 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
                           FILE *__restrict __stream);
# 631 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
                              size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
                               size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

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




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






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




extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
# 709 "/usr/include/stdio.h" 3 4



extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream);
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);




extern void clearerr (FILE *__stream) throw ();

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

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




extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw ();
extern int ferror_unlocked (FILE *__stream) throw ();








extern void perror (__const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 748 "/usr/include/stdio.h" 2 3 4




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




extern int fileno_unlocked (FILE *__stream) throw ();
# 767 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





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





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
                           __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
                            __const char *__restrict __format,
                            __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) throw ();



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


extern void funlockfile (FILE *__stream) throw ();
# 828 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 25 "/usr/include/bits/stdio.h" 3 4
#define __STDIO_INLINE inline







inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


inline int
getchar (void)
{
  return _IO_getc (stdin);
}




inline int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end, 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


inline int
getchar_unlocked (void)
{
  return (__builtin_expect ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end, 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


inline int
putchar_unlocked (int __c)
{
  return (__builtin_expect ((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end, 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





inline int
feof_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x10) != 0);
}


inline int
ferror_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x20) != 0);
}







#define fread_unlocked(ptr,size,n,stream) (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) && (size_t) ((size) * (n)) <= 8 && (size) != 0) ? ({ char *__ptr = (char *) (ptr); FILE *__stream = (stream); size_t __cnt; for (__cnt = (size) * (n); __cnt > 0; --__cnt) { int __c = _IO_getc_unlocked (__stream); if (__c == EOF) break; *__ptr++ = __c; } ((size_t) ((size) * (n)) - __cnt) / (size); }) : (((__builtin_constant_p (size) && (size) == 0) || (__builtin_constant_p (n) && (n) == 0)) ? ((void) (ptr), (void) (stream), (void) (size), (void) (n), 0) : fread_unlocked (ptr, size, n, stream))))
# 151 "/usr/include/bits/stdio.h" 3 4
#define fwrite_unlocked(ptr,size,n,stream) (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) && (size_t) ((size) * (n)) <= 8 && (size) != 0) ? ({ const char *__ptr = (const char *) (ptr); FILE *__stream = (stream); size_t __cnt; for (__cnt = (size) * (n); __cnt > 0; --__cnt) if (_IO_putc_unlocked (*__ptr++, __stream) == EOF) break; ((size_t) ((size) * (n)) - __cnt) / (size); }) : (((__builtin_constant_p (size) && (size) == 0) || (__builtin_constant_p (n) && (n) == 0)) ? ((void) (ptr), (void) (stream), (void) (size), n) : fwrite_unlocked (ptr, size, n, stream))))
# 169 "/usr/include/bits/stdio.h" 3 4
#undef __STDIO_INLINE
# 829 "/usr/include/stdio.h" 2 3 4


}
# 53 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 2 3
# 74 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 3
#undef getc




#undef putc
# 97 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 3
namespace std
{
  using ::FILE;
  using ::fpos_t;

  using ::clearerr;
  using ::fclose;
  using ::feof;
  using ::ferror;
  using ::fflush;
  using ::fgetc;
  using ::fgetpos;
  using ::fgets;
  using ::fopen;
  using ::fprintf;
  using ::fputc;
  using ::fputs;
  using ::fread;
  using ::freopen;
  using ::fscanf;
  using ::fseek;
  using ::fsetpos;
  using ::ftell;
  using ::fwrite;
  using ::getc;
  using ::getchar;
  using ::gets;
  using ::perror;
  using ::printf;
  using ::putc;
  using ::putchar;
  using ::puts;
  using ::remove;
  using ::rename;
  using ::rewind;
  using ::scanf;
  using ::setbuf;
  using ::setvbuf;
  using ::sprintf;
  using ::sscanf;
  using ::tmpfile;
  using ::tmpnam;
  using ::ungetc;
  using ::vfprintf;
  using ::vprintf;
  using ::vsprintf;
}
# 153 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 3
namespace __gnu_cxx
{
# 167 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdio" 3
  using ::snprintf;
  using ::vfscanf;
  using ::vscanf;
  using ::vsnprintf;
  using ::vsscanf;

}

namespace std
{
  using __gnu_cxx::snprintf;
  using __gnu_cxx::vfscanf;
  using __gnu_cxx::vscanf;
  using __gnu_cxx::vsnprintf;
  using __gnu_cxx::vsscanf;
}
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++io.h" 2 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr.h" 1 3
# 30 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr.h" 3
#define _GLIBCPP_GCC_GTHR_H 
# 95 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr.h" 3
#define _GLIBCPP_GTHREAD_USE_WEAK 1


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr-default.h" 1 3
# 30 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr-default.h" 3
#define _GLIBCPP_GCC_GTHR_POSIX_H 




#define __GTHREADS 1

# 1 "/usr/include/pthread.h" 1 3 4
# 16 "/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_timespec 
# 1 "/usr/include/time.h" 1 3 4
# 114 "/usr/include/time.h" 3 4
#define __timespec_defined 1



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


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


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



#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_STOPPED 0x02000000



struct sched_param
  {
    int __sched_priority;
  };

extern "C" {



extern int clone (int (*__fn) (void *__arg), void *__child_stack,
                  int __flags, void *__arg) throw ();


}





#define __defined_schedparam 1

struct __sched_param
  {
    int __sched_priority;
  };





#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(cpusetp) do { unsigned int __i; cpu_set_t *__arr = (cpusetp); for (__i = 0; __i < sizeof (cpu_set_t) / sizeof (__cpu_mask); ++__i) __arr->__bits[__i] = 0; } while (0)






#define __CPU_SET(cpu,cpusetp) ((cpusetp)->__bits[__CPUELT (cpu)] |= __CPUMASK (cpu))

#define __CPU_CLR(cpu,cpusetp) ((cpusetp)->__bits[__CPUELT (cpu)] &= ~__CPUMASK (cpu))

#define __CPU_ISSET(cpu,cpusetp) (((cpusetp)->__bits[__CPUELT (cpu)] & __CPUMASK (cpu)) != 0)
# 33 "/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 (cpu, cpusetp)
#define CPU_CLR(cpu,cpusetp) __CPU_CLR (cpu, cpusetp)
#define CPU_ISSET(cpu,cpusetp) __CPU_ISSET (cpu, cpusetp)
#define CPU_ZERO(cpusetp) __CPU_ZERO (cpusetp)



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


}
# 21 "/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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->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;









#define __time_t_defined 1





typedef __time_t time_t;










#define __clockid_t_defined 1




typedef __clockid_t clockid_t;






#define __timer_t_defined 1




typedef __timer_t timer_t;
# 129 "/usr/include/time.h" 3 4


struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;


  long int tm_gmtoff;
  __const char *tm_zone;




};








struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };


struct sigevent;





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))
# 309 "/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__));
# 324 "/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 ();
# 386 "/usr/include/time.h" 3 4
extern int getdate_err;
# 395 "/usr/include/time.h" 3 4
extern struct tm *getdate (__const char *__string);
# 409 "/usr/include/time.h" 3 4
extern int getdate_r (__const char *__restrict __string,
                      struct tm *__restrict __resbufp);


}
# 22 "/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
# 21 "/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
# 395 "/usr/include/signal.h" 3 4
}
# 25 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 20 "/usr/include/bits/pthreadtypes.h" 3 4
#define _BITS_PTHREADTYPES_H 1

#define __need_schedparam 
# 1 "/usr/include/bits/sched.h" 1 3 4
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4


struct _pthread_fastlock
{
  long int __status;
  int __spinlock;

};



typedef struct _pthread_descr_struct *_pthread_descr;
#define _PTHREAD_DESCR_DEFINED 




typedef struct __pthread_attr_s
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;





__extension__ typedef long long __pthread_cond_align_t;




typedef struct
{
  struct _pthread_fastlock __c_lock;
  _pthread_descr __c_waiting;
  char __padding[48 - sizeof (struct _pthread_fastlock)
                 - sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
  __pthread_cond_align_t __align;
} pthread_cond_t;



typedef struct
{
  int __dummy;
} pthread_condattr_t;


typedef unsigned int pthread_key_t;





typedef struct
{
  int __m_reserved;
  int __m_count;
  _pthread_descr __m_owner;
  int __m_kind;
  struct _pthread_fastlock __m_lock;
} pthread_mutex_t;



typedef struct
{
  int __mutexkind;
} pthread_mutexattr_t;



typedef int pthread_once_t;




typedef struct _pthread_rwlock_t
{
  struct _pthread_fastlock __rw_lock;
  int __rw_readers;
  _pthread_descr __rw_writer;
  _pthread_descr __rw_read_waiting;
  _pthread_descr __rw_write_waiting;
  int __rw_kind;
  int __rw_pshared;
} pthread_rwlock_t;



typedef struct
{
  int __lockkind;
  int __pshared;
} pthread_rwlockattr_t;




typedef volatile int pthread_spinlock_t;


typedef struct {
  struct _pthread_fastlock __ba_lock;
  int __ba_required;
  int __ba_present;
  _pthread_descr __ba_waiting;
} pthread_barrier_t;


typedef struct {
  int __pshared;
} pthread_barrierattr_t;





typedef unsigned long int pthread_t;
# 26 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/initspin.h" 1 3 4
# 23 "/usr/include/bits/initspin.h" 3 4
#define __LT_SPINLOCK_INIT 0


#define __LOCK_INITIALIZER { 0, __LT_SPINLOCK_INIT }
#define __ALT_LOCK_INITIALIZER { 0, __LT_SPINLOCK_INIT }
#define __ATOMIC_INITIALIZER { 0, __LT_SPINLOCK_INIT }
# 27 "/usr/include/pthread.h" 2 3 4


extern "C" {



#define PTHREAD_MUTEX_INITIALIZER {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, __LOCK_INITIALIZER}


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

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

#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP {0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __LOCK_INITIALIZER}



#define PTHREAD_COND_INITIALIZER {__LOCK_INITIALIZER, 0, "", 0}


#define PTHREAD_RWLOCK_INITIALIZER { __LOCK_INITIALIZER, 0, NULL, NULL, NULL, PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE }




#define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP { __LOCK_INITIALIZER, 0, NULL, NULL, NULL, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_PROCESS_PRIVATE }






enum
{
  PTHREAD_CREATE_JOINABLE,
#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
  PTHREAD_CREATE_DETACHED
#define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
};

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_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_ADAPTIVE_NP

};

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


enum
{
  PTHREAD_RWLOCK_PREFER_READER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
};


#define PTHREAD_ONCE_INIT 0





#define PTHREAD_BARRIER_SERIAL_THREAD -1




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)







extern int pthread_create (pthread_t *__restrict __threadp,
                           __const pthread_attr_t *__restrict __attr,
                           void *(*__start_routine) (void *),
                           void *__restrict __arg) throw ();


extern pthread_t pthread_self (void) throw ();


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ();


extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));




extern int pthread_join (pthread_t __th, void **__thread_return);





extern int pthread_detach (pthread_t __th) throw ();







extern int pthread_attr_init (pthread_attr_t *__attr) throw ();


extern int pthread_attr_destroy (pthread_attr_t *__attr) throw ();


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
                                        int __detachstate) throw ();


extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
                                        int *__detachstate) throw ();


extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
                                       __const struct sched_param *__restrict
                                       __param) throw ();


extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict
                                       __attr,
                                       struct sched_param *__restrict __param)
     throw ();


extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
     throw ();


extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict
                                        __attr, int *__restrict __policy)
     throw ();


extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
                                         int __inherit) throw ();


extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict
                                         __attr, int *__restrict __inherit)
     throw ();


extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
     throw ();


extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,
                                  int *__restrict __scope) throw ();



extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
                                      size_t __guardsize) throw ();


extern int pthread_attr_getguardsize (__const pthread_attr_t *__restrict
                                      __attr, size_t *__restrict __guardsize)
     throw ();






extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
                                      void *__stackaddr) throw ();


extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
                                      __attr, void **__restrict __stackaddr)
     throw ();





extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
                                  size_t __stacksize) throw ();


extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
                                  void **__restrict __stackaddr,
                                  size_t *__restrict __stacksize) throw ();





extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
                                      size_t __stacksize) throw ();


extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict
                                      __attr, size_t *__restrict __stacksize)
     throw ();





extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) throw ();






extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
                                  __const struct sched_param *__param)
     throw ();


extern int pthread_getschedparam (pthread_t __target_thread,
                                  int *__restrict __policy,
                                  struct sched_param *__restrict __param)
     throw ();



extern int pthread_getconcurrency (void) throw ();


extern int pthread_setconcurrency (int __level) throw ();







extern int pthread_yield (void) throw ();






extern int pthread_mutex_init (pthread_mutex_t *__restrict __mutex,
                               __const pthread_mutexattr_t *__restrict
                               __mutex_attr) throw ();


extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) throw ();


extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) throw ();


extern int pthread_mutex_lock (pthread_mutex_t *__mutex) throw ();



extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
                                    __const struct timespec *__restrict
                                    __abstime) throw ();



extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) throw ();






extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) throw ();


extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) throw ();


extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
                                         __restrict __attr,
                                         int *__restrict __pshared) throw ();


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
                                         int __pshared) throw ();





extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
     throw ();


extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
                                      __attr, int *__restrict __kind) throw ();







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
                              __const pthread_condattr_t *__restrict
                              __cond_attr) throw ();


extern int pthread_cond_destroy (pthread_cond_t *__cond) throw ();


extern int pthread_cond_signal (pthread_cond_t *__cond) throw ();


extern int pthread_cond_broadcast (pthread_cond_t *__cond) throw ();



extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
                              pthread_mutex_t *__restrict __mutex);





extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
                                   pthread_mutex_t *__restrict __mutex,
                                   __const struct timespec *__restrict
                                   __abstime);




extern int pthread_condattr_init (pthread_condattr_t *__attr) throw ();


extern int pthread_condattr_destroy (pthread_condattr_t *__attr) throw ();


extern int pthread_condattr_getpshared (__const pthread_condattr_t *
                                        __restrict __attr,
                                        int *__restrict __pshared) throw ();


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
                                        int __pshared) throw ();







extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
                                __const pthread_rwlockattr_t *__restrict
                                __attr) throw ();


extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) throw ();



extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
                                       __const struct timespec *__restrict
                                       __abstime) throw ();



extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) throw ();



extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
                                       __const struct timespec *__restrict
                                       __abstime) throw ();



extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) throw ();





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) throw ();


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) throw ();


extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *
                                          __restrict __attr,
                                          int *__restrict __pshared) throw ();


extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
                                          int __pshared) throw ();


extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *__attr,
                                          int *__pref) throw ();


extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
                                          int __pref) throw ();
# 510 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     throw ();


extern int pthread_spin_destroy (pthread_spinlock_t *__lock) throw ();


extern int pthread_spin_lock (pthread_spinlock_t *__lock) throw ();


extern int pthread_spin_trylock (pthread_spinlock_t *__lock) throw ();


extern int pthread_spin_unlock (pthread_spinlock_t *__lock) throw ();




extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
                                 __const pthread_barrierattr_t *__restrict
                                 __attr, unsigned int __count) throw ();

extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) throw ();

extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) throw ();

extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) throw ();

extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
                                           __restrict __attr,
                                           int *__restrict __pshared) throw ();

extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
                                           int __pshared) throw ();

extern int pthread_barrier_wait (pthread_barrier_t *__barrier) throw ();
# 557 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
                               void (*__destr_function) (void *)) throw ();


extern int pthread_key_delete (pthread_key_t __key) throw ();


extern int pthread_setspecific (pthread_key_t __key,
                                __const void *__pointer) throw ();


extern void *pthread_getspecific (pthread_key_t __key) throw ();
# 577 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
                         void (*__init_routine) (void)) throw ();






extern int pthread_setcancelstate (int __state, int *__oldstate);



extern int pthread_setcanceltype (int __type, int *__oldtype);


extern int pthread_cancel (pthread_t __cancelthread);




extern void pthread_testcancel (void);
# 607 "/usr/include/pthread.h" 3 4
#define pthread_cleanup_push(routine,arg) { struct _pthread_cleanup_buffer _buffer; _pthread_cleanup_push (&_buffer, (routine), (arg));



extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer,
                                   void (*__routine) (void *),
                                   void *__arg) throw ();




#define pthread_cleanup_pop(execute) _pthread_cleanup_pop (&_buffer, (execute)); }


extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer,
                                  int __execute) throw ();





#define pthread_cleanup_push_defer_np(routine,arg) { struct _pthread_cleanup_buffer _buffer; _pthread_cleanup_push_defer (&_buffer, (routine), (arg));



extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,
                                         void (*__routine) (void *),
                                         void *__arg) throw ();





#define pthread_cleanup_pop_restore_np(execute) _pthread_cleanup_pop_restore (&_buffer, (execute)); }


extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,
                                          int __execute) throw ();





extern int pthread_getcpuclockid (pthread_t __thread_id,
                                  __clockid_t *__clock_id) throw ();




# 1 "/usr/include/bits/sigthread.h" 1 3 4
# 21 "/usr/include/bits/sigthread.h" 3 4
#define _BITS_SIGTHREAD_H 1
# 31 "/usr/include/bits/sigthread.h" 3 4
extern int pthread_sigmask (int __how,
                            __const __sigset_t *__restrict __newmask,
                            __sigset_t *__restrict __oldmask)throw ();


extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
# 657 "/usr/include/pthread.h" 2 3 4
# 672 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
                           void (*__parent) (void),
                           void (*__child) (void)) throw ();




extern void pthread_kill_other_threads_np (void) throw ();

}
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-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 200112L





#define _POSIX2_VERSION 200112L



#define _POSIX2_C_BIND 200112L



#define _POSIX2_C_DEV 200112L



#define _POSIX2_SW_DEV 200112L



#define _POSIX2_LOCALEDEF 200112L



#define _XOPEN_VERSION 500





#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
# 171 "/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 _POSIX_OPT_H 1


#define _POSIX_JOB_CONTROL 1


#define _POSIX_SAVED_IDS 1


#define _POSIX_PRIORITY_SCHEDULING 200112L


#define _POSIX_SYNCHRONIZED_IO 200112L


#define _POSIX_FSYNC 200112L


#define _POSIX_MAPPED_FILES 200112L


#define _POSIX_MEMLOCK 200112L


#define _POSIX_MEMLOCK_RANGE 200112L


#define _POSIX_MEMORY_PROTECTION 200112L


#define _POSIX_CHOWN_RESTRICTED 1



#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 200112L


#define _POSIX_REENTRANT_FUNCTIONS 1
#define _POSIX_THREAD_SAFE_FUNCTIONS 200112L


#define _POSIX_THREAD_PRIORITY_SCHEDULING 200112L


#define _POSIX_THREAD_ATTR_STACKSIZE 200112L


#define _POSIX_THREAD_ATTR_STACKADDR 200112L


#define _POSIX_SEMAPHORES 200112L


#define _POSIX_REALTIME_SIGNALS 200112L


#define _POSIX_ASYNCHRONOUS_IO 200112L
#define _POSIX_ASYNC_IO 1

#define _LFS_ASYNCHRONOUS_IO 1


#define _LFS64_ASYNCHRONOUS_IO 1


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


#define _POSIX_SHARED_MEMORY_OBJECTS 200112L


#define _POSIX_CPUTIME 200112L


#define _POSIX_THREAD_CPUTIME 200112L


#define _POSIX_REGEXP 1


#define _POSIX_READER_WRITER_LOCKS 200112L


#define _POSIX_SHELL 1


#define _POSIX_TIMEOUTS 200112L


#define _POSIX_SPIN_LOCKS 200112L


#define _POSIX_SPAWN 200112L


#define _POSIX_TIMERS 200112L


#define _POSIX_BARRIERS 200112L


#define _POSIX_MESSAGE_PASSING 200112L


#define _POSIX_MONOTONIC_CLOCK 0
# 172 "/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
# 19 "/usr/include/bits/wordsize.h" 3 4
#define __WORDSIZE 32
# 24 "/usr/include/bits/environments.h" 2 3 4
# 61 "/usr/include/bits/environments.h" 3 4
#define _POSIX_V6_ILP32_OFF32 1
#define _POSIX_V6_ILP32_OFFBIG 1
#define _XBS5_ILP32_OFF32 1
#define _XBS5_ILP32_OFFBIG 1





#define _POSIX_V6_LP64_OFF64 -1
#define _POSIX_V6_LPBIG_OFFBIG -1
#define _XBS5_LP64_OFF64 -1
#define _XBS5_LPBIG_OFFBIG -1
# 176 "/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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 196 "/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 
# 236 "/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 ();




extern int euidaccess (__const char *__name, int __type) throw ();
# 274 "/usr/include/unistd.h" 3 4
#define L_SET SEEK_SET
#define L_INCR SEEK_CUR
#define L_XTND SEEK_END
# 286 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 298 "/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);
# 328 "/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);
# 356 "/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 ();
# 378 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 390 "/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);
# 414 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
     throw ();



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




extern int chdir (__const char *__path) throw ();



extern int fchdir (int __fd) throw ();
# 448 "/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 ();




extern int dup (int __fd) throw ();


extern int dup2 (int __fd, int __fd2) throw ();


extern char **__environ;

extern char **environ;





extern int execve (__const char *__path, char *__const __argv[],
                   char *__const __envp[]) throw ();




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




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



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



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



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




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




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

  };


enum
  {
    _CS_PATH,
#define _CS_PATH _CS_PATH

    _CS_V6_WIDTH_RESTRICTED_ENVS,
#define _CS_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_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
  };
# 526 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (__const char *__path, int __name) throw ();


extern long int fpathconf (int __fd, int __name) throw ();


extern long int sysconf (int __name) throw () __attribute__ ((__const__));



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 ();
# 561 "/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 ();
# 587 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
# 605 "/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 *__euid, __uid_t *__ruid, __uid_t *__suid);



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



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



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






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



extern int isatty (int __fd) throw ();





extern int ttyslot (void) throw ();




extern int link (__const char *__from, __const char *__to) throw ();



extern int symlink (__const char *__from, __const char *__to) throw ();




extern int readlink (__const char *__restrict __path, char *__restrict __buf,
                     size_t __len) throw ();



extern int unlink (__const char *__name) throw ();


extern int rmdir (__const char *__path) throw ();



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




extern int setlogin (__const char *__name) throw ();







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



#undef __need_getopt
# 776 "/usr/include/unistd.h" 2 3 4







extern int gethostname (char *__name, size_t __len) throw ();






extern int sethostname (__const char *__name, size_t __len) throw ();



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





extern int getdomainname (char *__name, size_t __len) throw ();
extern int setdomainname (__const char *__name, size_t __len) throw ();





extern int vhangup (void) throw ();


extern int revoke (__const char *__file) throw ();







extern int profil (unsigned short int *__sample_buffer, size_t __size,
                   size_t __offset, unsigned int __scale) throw ();





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



extern char *getpass (__const char *__prompt);
# 857 "/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 truncate (__const char *__file, __off_t __length) throw ();
# 888 "/usr/include/unistd.h" 3 4
extern int truncate64 (__const char *__file, __off64_t __length) throw ();




extern int ftruncate (int __fd, __off_t __length) throw ();
# 903 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw ();





extern int getdtablesize (void) throw ();
# 918 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw ();





extern void *sbrk (intptr_t __delta) throw ();
# 939 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 956 "/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);
# 972 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len);
# 982 "/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; }))
# 993 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes) throw ();







extern char *crypt (__const char *__key, __const char *__salt) throw ();



extern void encrypt (char *__block, int __edflag) throw ();






extern void swab (__const void *__restrict __from, void *__restrict __to,
                  ssize_t __n) throw ();







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


}
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr-default.h" 2 3

typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;

#define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
#define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT



#pragma weak pthread_once
#pragma weak pthread_key_create
#pragma weak pthread_key_delete
#pragma weak pthread_getspecific
#pragma weak pthread_setspecific
#pragma weak pthread_create

#pragma weak pthread_mutex_lock
#pragma weak pthread_mutex_trylock
#pragma weak pthread_mutex_unlock
# 87 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  static void *const __gthread_active_ptr = (void *) &pthread_create;
  return __gthread_active_ptr != 0;
}
# 449 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_once (__gthread_once_t *once, void (*func) (void))
{
  if (__gthread_active_p ())
    return pthread_once (once, func);
  else
    return -1;
}

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

static inline int
__gthread_key_dtor (__gthread_key_t key, void *ptr)
{

  if (ptr)
    return pthread_setspecific (key, 0);
  else
    return 0;
}

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

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

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

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

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

static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_unlock (mutex);
  else
    return 0;
}
# 99 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/gthr.h" 2 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/c++io.h" 2 3

namespace std
{

  typedef long streamoff;
  typedef ptrdiff_t streamsize;

  typedef ptrdiff_t wstreamsize;

  typedef fpos_t __c_streampos;

  typedef __gthread_mutex_t __c_lock;


  typedef FILE __c_file;


  struct __ios_flags
  {
    typedef short __int_type;

    static const __int_type _S_boolalpha = 0x0001;
    static const __int_type _S_dec = 0x0002;
    static const __int_type _S_fixed = 0x0004;
    static const __int_type _S_hex = 0x0008;
    static const __int_type _S_internal = 0x0010;
    static const __int_type _S_left = 0x0020;
    static const __int_type _S_oct = 0x0040;
    static const __int_type _S_right = 0x0080;
    static const __int_type _S_scientific = 0x0100;
    static const __int_type _S_showbase = 0x0200;
    static const __int_type _S_showpoint = 0x0400;
    static const __int_type _S_showpos = 0x0800;
    static const __int_type _S_skipws = 0x1000;
    static const __int_type _S_unitbuf = 0x2000;
    static const __int_type _S_uppercase = 0x4000;
    static const __int_type _S_adjustfield = 0x0020 | 0x0080 | 0x0010;
    static const __int_type _S_basefield = 0x0002 | 0x0040 | 0x0008;
    static const __int_type _S_floatfield = 0x0100 | 0x0004;


    static const __int_type _S_badbit = 0x01;
    static const __int_type _S_eofbit = 0x02;
    static const __int_type _S_failbit = 0x04;


    static const __int_type _S_app = 0x01;
    static const __int_type _S_ate = 0x02;
    static const __int_type _S_bin = 0x04;
    static const __int_type _S_in = 0x08;
    static const __int_type _S_out = 0x10;
    static const __int_type _S_trunc = 0x20;
  };
}
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/fpos.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwchar" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwchar" 3
#define _CPP_CWCHAR 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwchar" 3



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ctime" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ctime" 3
#define _CPP_CTIME 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ctime" 3
# 64 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ctime" 3
namespace std
{
  using ::clock_t;
  using ::time_t;
  using ::tm;

  using ::clock;
  using ::difftime;
  using ::mktime;
  using ::time;
  using ::asctime;
  using ::ctime;
  using ::gmtime;
  using ::localtime;
  using ::strftime;
}
# 52 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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 



#define __need___va_list 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stdarg.h" 1 3 4
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stdarg.h" 3 4
#undef __need___va_list
# 41 "/usr/include/wchar.h" 2 3 4


#define __need_size_t 
#define __need_wchar_t 
#define __need_NULL 

#define __need_wint_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 344 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wchar_t
# 356 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wint_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 49 "/usr/include/wchar.h" 2 3 4
# 93 "/usr/include/wchar.h" 3 4


typedef __mbstate_t mbstate_t;







#define WCHAR_MIN __WCHAR_MIN
#define WCHAR_MAX __WCHAR_MAX



#define WEOF (0xffffffffu)
# 118 "/usr/include/wchar.h" 3 4
extern "C" {




struct tm;









extern wchar_t *wcscpy (wchar_t *__restrict __dest,
                        __const wchar_t *__restrict __src) throw ();

extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
                         __const wchar_t *__restrict __src, size_t __n)
     throw ();


extern wchar_t *wcscat (wchar_t *__restrict __dest,
                        __const wchar_t *__restrict __src) throw ();

extern wchar_t *wcsncat (wchar_t *__restrict __dest,
                         __const wchar_t *__restrict __src, size_t __n)
     throw ();


extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
     throw () __attribute__ ((__pure__));

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




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


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





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

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





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



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








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




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


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




extern wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __attribute__ ((__pure__));

extern wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __attribute__ ((__pure__));





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





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


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

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

extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __attribute__ ((__pure__));


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


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




extern wchar_t *wcswcs (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __attribute__ ((__pure__));




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





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


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


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



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


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





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






extern wint_t btowc (int __c) throw ();



extern int wctob (wint_t __c) throw ();



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



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


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


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




extern __inline size_t mbrlen (__const char *__restrict __s, size_t __n,
                               mbstate_t *__restrict __ps) throw ()
{ return (__ps != __null
          ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }





extern size_t mbsrtowcs (wchar_t *__restrict __dst,
                         __const char **__restrict __src, size_t __len,
                         mbstate_t *__restrict __ps) throw ();



extern size_t wcsrtombs (char *__restrict __dst,
                         __const wchar_t **__restrict __src, size_t __len,
                         mbstate_t *__restrict __ps) throw ();






extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
                          __const char **__restrict __src, size_t __nmc,
                          size_t __len, mbstate_t *__restrict __ps) throw ();



extern size_t wcsnrtombs (char *__restrict __dst,
                          __const wchar_t **__restrict __src,
                          size_t __nwc, size_t __len,
                          mbstate_t *__restrict __ps) throw ();






extern int wcwidth (wchar_t __c) throw ();



extern int wcswidth (__const wchar_t *__s, size_t __n) throw ();






extern double wcstod (__const wchar_t *__restrict __nptr,
                      wchar_t **__restrict __endptr) throw ();



extern float wcstof (__const wchar_t *__restrict __nptr,
                     wchar_t **__restrict __endptr) throw ();
extern long double wcstold (__const wchar_t *__restrict __nptr,
                            wchar_t **__restrict __endptr) throw ();





extern long int wcstol (__const wchar_t *__restrict __nptr,
                        wchar_t **__restrict __endptr, int __base) throw ();



extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
                                  wchar_t **__restrict __endptr, int __base)
     throw ();




__extension__
extern long long int wcstoll (__const wchar_t *__restrict __nptr,
                              wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstoull (__const wchar_t *__restrict __nptr,
                                        wchar_t **__restrict __endptr,
                                        int __base) throw ();






__extension__
extern long long int wcstoq (__const wchar_t *__restrict __nptr,
                             wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr,
                                       wchar_t **__restrict __endptr,
                                       int __base) throw ();
# 448 "/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 double __wcstod_internal (__const wchar_t *__restrict __nptr,
                                 wchar_t **__restrict __endptr, int __group)
     throw ();
extern float __wcstof_internal (__const wchar_t *__restrict __nptr,
                                wchar_t **__restrict __endptr, int __group)
     throw ();
extern long double __wcstold_internal (__const wchar_t *__restrict __nptr,
                                       wchar_t **__restrict __endptr,
                                       int __group) throw ();


extern long int __wcstol_internal (__const wchar_t *__restrict __nptr,
                                   wchar_t **__restrict __endptr,
                                   int __base, int __group) throw ();
#define __wcstol_internal_defined 1


extern unsigned long int __wcstoul_internal (__const wchar_t *__restrict __npt,
                                             wchar_t **__restrict __endptr,
                                             int __base, int __group) throw ();
#define __wcstoul_internal_defined 1


__extension__
extern long long int __wcstoll_internal (__const wchar_t *__restrict __nptr,
                                         wchar_t **__restrict __endptr,
                                         int __base, int __group) throw ();
#define __wcstoll_internal_defined 1


__extension__
extern unsigned long long int __wcstoull_internal (__const wchar_t *
                                                   __restrict __nptr,
                                                   wchar_t **
                                                   __restrict __endptr,
                                                   int __base,
                                                   int __group) throw ();
#define __wcstoull_internal_defined 1







extern __inline double wcstod (__const wchar_t *__restrict __nptr,
                               wchar_t **__restrict __endptr) throw ()
{ return __wcstod_internal (__nptr, __endptr, 0); }
extern __inline long int wcstol (__const wchar_t *__restrict __nptr,
                                 wchar_t **__restrict __endptr,
                                 int __base) throw ()
{ return __wcstol_internal (__nptr, __endptr, __base, 0); }
extern __inline unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
                                           wchar_t **__restrict __endptr,
                                           int __base) throw ()
{ return __wcstoul_internal (__nptr, __endptr, __base, 0); }



extern __inline float wcstof (__const wchar_t *__restrict __nptr,
                              wchar_t **__restrict __endptr) throw ()
{ return __wcstof_internal (__nptr, __endptr, 0); }
extern __inline long double wcstold (__const wchar_t *__restrict __nptr,
                                     wchar_t **__restrict __endptr) throw ()
{ return __wcstold_internal (__nptr, __endptr, 0); }


__extension__
extern __inline long long int wcstoq (__const wchar_t *__restrict __nptr,
                                      wchar_t **__restrict __endptr,
                                      int __base) throw ()
{ return __wcstoll_internal (__nptr, __endptr, __base, 0); }
__extension__
extern __inline unsigned long long int wcstouq (__const wchar_t *
                                                __restrict __nptr,
                                                wchar_t **__restrict __endptr,
                                                int __base) throw ()
{ return __wcstoull_internal (__nptr, __endptr, __base, 0); }







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








extern int fwide (__FILE *__fp, int __mode) throw ();






extern int fwprintf (__FILE *__restrict __stream,
                     __const wchar_t *__restrict __format, ...)
                                                           ;




extern int wprintf (__const wchar_t *__restrict __format, ...)
                                                           ;

extern int swprintf (wchar_t *__restrict __s, size_t __n,
                     __const wchar_t *__restrict __format, ...)
     throw () ;





extern int vfwprintf (__FILE *__restrict __s,
                      __const wchar_t *__restrict __format,
                      __gnuc_va_list __arg)
                                                           ;




extern int vwprintf (__const wchar_t *__restrict __format,
                     __gnuc_va_list __arg)
                                                           ;


extern int vswprintf (wchar_t *__restrict __s, size_t __n,
                      __const wchar_t *__restrict __format,
                      __gnuc_va_list __arg)
     throw () ;






extern int fwscanf (__FILE *__restrict __stream,
                    __const wchar_t *__restrict __format, ...)
                                                          ;




extern int wscanf (__const wchar_t *__restrict __format, ...)
                                                          ;

extern int swscanf (__const wchar_t *__restrict __s,
                    __const wchar_t *__restrict __format, ...)
     throw () ;











extern int vfwscanf (__FILE *__restrict __s,
                     __const wchar_t *__restrict __format,
                     __gnuc_va_list __arg)
                                                          ;




extern int vwscanf (__const wchar_t *__restrict __format,
                    __gnuc_va_list __arg)
                                                          ;

extern int vswscanf (__const wchar_t *__restrict __s,
                     __const wchar_t *__restrict __format,
                     __gnuc_va_list __arg)
     throw () ;










extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);





extern wint_t getwchar (void);






extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);





extern wint_t putwchar (wchar_t __wc);







extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
                        __FILE *__restrict __stream);





extern int fputws (__const wchar_t *__restrict __ws,
                   __FILE *__restrict __stream);






extern wint_t ungetwc (wint_t __wc, __FILE *__stream);

# 736 "/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);
# 762 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 772 "/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 ();
# 817 "/usr/include/wchar.h" 3 4
}
# 55 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwchar" 2 3
# 69 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 133 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwchar" 3
namespace std
{
  using ::wint_t;

  using ::btowc;
  using ::fgetwc;
  using ::fgetws;
  using ::fputwc;
  using ::fputws;
  using ::fwide;
  using ::fwprintf;
  using ::fwscanf;
  using ::getwc;
  using ::getwchar;
  using ::mbrlen;
  using ::mbrtowc;
  using ::mbsinit;
  using ::mbsrtowcs;
  using ::putwc;
  using ::putwchar;
  using ::swprintf;
  using ::swscanf;
  using ::ungetwc;
  using ::vfwprintf;
  using ::vfwscanf;
  using ::vswprintf;
  using ::vswscanf;
  using ::vwprintf;
  using ::vwscanf;
  using ::wcrtomb;
  using ::wcscat;
  using ::wcscmp;
  using ::wcscoll;
  using ::wcscpy;
  using ::wcscspn;



  using ::wcslen;
  using ::wcsncat;
  using ::wcsncmp;
  using ::wcsncpy;
  using ::wcsrtombs;
  using ::wcsspn;
  using ::wcstod;
  using ::wcstof;
  using ::wcstok;
  using ::wcstol;
  using ::wcstoul;
  using ::wcsxfrm;
  using ::wctob;
  using ::wmemcmp;
  using ::wmemcpy;
  using ::wmemmove;
  using ::wmemset;
  using ::wprintf;
  using ::wscanf;

  using ::wcschr;

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

  using ::wcspbrk;

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

  using ::wcsrchr;

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

  using ::wcsstr;

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

  using ::wmemchr;

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







namespace __gnu_cxx
{





  using ::wcstold;
# 244 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using __gnu_cxx::wcstold;
  using __gnu_cxx::wcstoll;
  using __gnu_cxx::wcstoull;
}
# 46 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/fpos.h" 2 3

namespace std
{






  template<typename _StateT>
    class fpos
    {
    public:

      typedef _StateT __state_type;

    private:
      streamoff _M_off;
      __state_type _M_st;

    public:
      __state_type
      state() const { return _M_st; }

      void
      state(__state_type __st) { _M_st = __st; }



      fpos(): _M_off(streamoff()), _M_st(__state_type()) { }

      fpos(streamoff __off, __state_type __st = __state_type())
      : _M_off(__off), _M_st(__st) { }

      operator streamoff() const { return _M_off; }

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

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

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

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

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

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

      streamoff
      _M_position() const { return _M_off; }

      void
      _M_position(streamoff __off) { _M_off = __off; }
    };


  typedef fpos<mbstate_t> streampos;


  typedef fpos<mbstate_t> wstreampos;

}
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 3
#define __throw_exception_again throw
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 51 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iosfwd" 2 3

namespace std
{
  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ios;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_streambuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_istream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_iostream;

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

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

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

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

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_filebuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ifstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ofstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_fstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class ostreambuf_iterator;



  class ios_base;
# 136 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;


}
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception" 1 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception" 3
#define __EXCEPTION__ 

extern "C++" {

namespace std
{
# 52 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception" 3
  class exception
  {
  public:
    exception() throw() { }
    virtual ~exception() throw();


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



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


    virtual ~bad_exception() throw();
  };


  typedef void (*terminate_handler) ();

  typedef void (*unexpected_handler) ();


  terminate_handler set_terminate(terminate_handler) throw();


  void terminate() __attribute__ ((__noreturn__));


  unexpected_handler set_unexpected(unexpected_handler) throw();


  void unexpected() __attribute__ ((__noreturn__));
# 100 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception" 3
  bool uncaught_exception() throw();
}

namespace __gnu_cxx
{
# 113 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception" 3
  void __verbose_terminate_handler ();
}

}
# 46 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/char_traits.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/char_traits.h" 3
#define _CPP_BITS_CHAR_TRAITS_H 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/char_traits.h" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstring" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstring" 3
#define _CPP_CSTRING 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstring" 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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 34 "/usr/include/string.h" 2 3 4




extern void *memcpy (void *__restrict __dest,
                     __const void *__restrict __src, size_t __n) throw ();


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     throw ();






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
                      int __c, size_t __n)
     throw ();





extern void *memset (void *__s, int __c, size_t __n) throw ();


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern void *memchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__));





extern void *rawmemchr (__const void *__s, int __c) throw () __attribute__ ((__pure__));


extern void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__));





extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();

extern char *strncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) throw ();


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     throw ();

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
                      size_t __n) throw ();


extern int strcmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern int strcoll (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));

extern size_t strxfrm (char *__restrict __dest,
                       __const char *__restrict __src, size_t __n) throw ();

# 117 "/usr/include/string.h" 3 4
extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
     throw () __attribute__ ((__pure__));

extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
                         __locale_t __l) throw ();




extern char *strdup (__const char *__s) throw () __attribute__ ((__malloc__));






extern char *strndup (__const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__));




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


extern char *strchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));

extern char *strrchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));





extern char *strchrnul (__const char *__s, int __c) throw () __attribute__ ((__pure__));





extern size_t strcspn (__const char *__s, __const char *__reject)
     throw () __attribute__ ((__pure__));


extern size_t strspn (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__));

extern char *strpbrk (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__));

extern char *strstr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__));



extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     throw ();




extern char *__strtok_r (char *__restrict __s,
                         __const char *__restrict __delim,
                         char **__restrict __save_ptr) throw ();

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
                       char **__restrict __save_ptr) throw ();




extern char *strcasestr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__));






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



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





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





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





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

# 268 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) throw ();





extern void __bzero (void *__s, size_t __n) throw ();



extern void bcopy (__const void *__src, void *__dest, size_t __n) throw ();


extern void bzero (void *__s, size_t __n) throw ();


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern char *index (__const char *__s, int __c) throw () __attribute__ ((__pure__));


extern char *rindex (__const char *__s, int __c) throw () __attribute__ ((__pure__));



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


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__));





extern int strcasecmp_l (__const char *__s1, __const char *__s2,
                         __locale_t __loc) throw () __attribute__ ((__pure__));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
                          size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__));





extern char *strsep (char **__restrict __stringp,
                     __const char *__restrict __delim) throw ();




extern int strverscmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));


extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();



extern char *__stpncpy (char *__restrict __dest,
                        __const char *__restrict __src, size_t __n) throw ();
extern char *stpncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) throw ();


extern char *strfry (char *__string) throw ();


extern void *memfrob (void *__s, size_t __n) throw ();






extern char *basename (__const char *__filename) throw ();
# 400 "/usr/include/string.h" 3 4
}
# 52 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstring" 2 3
# 77 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstring" 3
namespace std
{
  using ::memcpy;
  using ::memmove;
  using ::strcpy;
  using ::strncpy;
  using ::strcat;
  using ::strncat;
  using ::memcmp;
  using ::strcmp;
  using ::strcoll;
  using ::strncmp;
  using ::strxfrm;
  using ::strcspn;
  using ::strspn;
  using ::strtok;
  using ::memset;
  using ::strerror;
  using ::strlen;

  using ::memchr;

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

  using ::strchr;

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

  using ::strpbrk;

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

  using ::strrchr;

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

  using ::strstr;

  inline char*
  strstr(char* __s1, const char* __s2)
  { return __builtin_strstr(const_cast<const char*>(__s1), __s2); }
}
# 46 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/char_traits.h" 2 3


namespace std
{
# 61 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/char_traits.h" 3
  template<class _CharT>
    struct char_traits
    {
      typedef _CharT char_type;

      typedef unsigned long 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);

      static bool
      eq(const char_type& __c1, const char_type& __c2);

      static bool
      lt(const char_type& __c1, const char_type& __c2);

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

      static size_t
      length(const char_type* __s);

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

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

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

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

      static char_type
      to_char_type(const int_type& __c);

      static int_type
      to_int_type(const char_type& __c);

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2);

      static int_type
      eof();

      static int_type
      not_eof(const int_type& __c);
    };



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

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

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

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

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

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

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

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

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

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

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



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

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

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

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




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

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

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

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

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

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

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

      static char_type*
      move(char_type* __s1, const char_type* __s2, int_type __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; }
  };


  template<typename _CharT, typename _Traits>
    struct _Char_traits_match
    {
      _CharT _M_c;
      _Char_traits_match(_CharT const& __c) : _M_c(__c) { }

      bool
      operator()(_CharT const& __a) { return _Traits::eq(_M_c, __a); }
    };
}
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 2 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/localefwd.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/localefwd.h" 3
#define _CPP_BITS_LOCALE_FWD_H 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/localefwd.h" 3




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 3
#define __throw_exception_again throw
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/localefwd.h" 2 3

namespace std
{

  class locale;


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

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

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

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

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

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

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

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

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

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

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

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

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


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

  template<> class ctype<wchar_t>;

  template<typename _CharT>
    class ctype_byname;


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

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

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


  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class num_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class num_put;
  template<typename _CharT> class numpunct;
  template<typename _CharT> class numpunct_byname;


  template<typename _CharT>
    class collate;
  template<typename _CharT> class
    collate_byname;


  class time_base;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get_byname;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put_byname;


  class money_base;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class money_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class money_put;
  template<typename _CharT, bool _Intl = false>
    class moneypunct;
  template<typename _CharT, bool _Intl = false>
    class moneypunct_byname;


  class messages_base;
  template<typename _CharT>
    class messages;
  template<typename _CharT>
    class messages_byname;

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

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw();
}
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
#define _CPP_BITS_IOSBASE_H 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/atomicity.h" 1 3
# 31 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/atomicity.h" 3
#define _BITS_ATOMICITY_H 1

typedef int _Atomic_word;

static inline _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add (volatile _Atomic_word *__mem, int __val)
{
  register _Atomic_word __result;
  __asm__ __volatile__ ("lock; xadd{l} {%0,%1|%1,%0}"
                        : "=r" (__result), "+m" (*__mem)
                        : "0" (__val)
                        : "memory");
  return __result;
}

static inline void
__attribute__ ((__unused__))
__atomic_add (volatile _Atomic_word* __mem, int __val)
{
  __asm__ __volatile__ ("lock; add{l} {%1,%0|%0,%1}"
                        : "+m" (*__mem) : "ir" (__val) : "memory");
}
# 46 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 2 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_classes.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_classes.h" 3
#define _CPP_BITS_LOCALE_CLASSES_H 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_classes.h" 3



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 3
#define _CPP_STRING 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 3




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 1 3
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
#define _CPP_MEMORY 1

       
# 53 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
#define __GLIBCPP_INTERNAL_ALGOBASE_H 



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/climits" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/climits" 3
#define _CPP_CLIMITS 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/climits" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 1 3 4






#define _GCC_LIMITS_H_ 



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/syslimits.h" 1 3 4





#define _GCC_NEXT_LIMITS_H 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 24 "/usr/include/limits.h" 3 4
#define _LIBC_LIMITS_H_ 1







#define MB_LEN_MAX 16
# 144 "/usr/include/limits.h" 3 4
# 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 



# 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 CHILD_MAX 999
#define OPEN_MAX 256
#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
# 37 "/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



#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

#define PTHREAD_THREADS_MAX 16384



#define AIO_PRIO_DELTA_MAX 20


#define PTHREAD_STACK_MIN 16384


#define TIMER_MAX 256


#define DELAYTIMER_MAX 2147483647


#define TTY_NAME_MAX 32


#define LOGIN_NAME_MAX 256


#define HOST_NAME_MAX 64


#define MQ_PRIO_MAX 32768
# 146 "/usr/include/bits/posix1_lim.h" 2 3 4



#define SSIZE_MAX LONG_MAX
# 145 "/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)
# 149 "/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
# 24 "/usr/include/bits/stdio_lim.h" 3 4
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096


#define L_ctermid 9
#define L_cuserid 9




#undef FOPEN_MAX
#define FOPEN_MAX 16



#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
# 130 "/usr/include/bits/xopen_lim.h" 3 4
#define LONG_BIT 32
# 153 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/syslimits.h" 2 3 4
#undef _GCC_NEXT_LIMITS_H
# 12 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 2 3 4


#define _LIMITS_H___ 



#define CHAR_BIT __CHAR_BIT__
# 27 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 3 4
#define SCHAR_MIN (-SCHAR_MAX - 1)

#define SCHAR_MAX __SCHAR_MAX__






#define UCHAR_MAX (SCHAR_MAX * 2 + 1)
# 51 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 3 4
#define CHAR_MIN SCHAR_MIN

#define CHAR_MAX SCHAR_MAX




#define SHRT_MIN (-SHRT_MAX - 1)

#define SHRT_MAX __SHRT_MAX__






#define USHRT_MAX (SHRT_MAX * 2 + 1)




#define INT_MIN (-INT_MAX - 1)

#define INT_MAX __INT_MAX__



#define UINT_MAX (INT_MAX * 2U + 1U)




#define LONG_MIN (-LONG_MAX - 1L)

#define LONG_MAX __LONG_MAX__



#define ULONG_MAX (LONG_MAX * 2UL + 1UL)
# 106 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/limits.h" 3 4
#define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL)

#define LONG_LONG_MAX __LONG_LONG_MAX__



#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL)
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/climits" 2 3
# 67 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdlib" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdlib" 3
#define _CPP_CSTDLIB 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 344 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wchar_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->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 __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) (__extension__ ({ int __status = (status); !__WIFSTOPPED(__status) && !__WIFEXITED(__status); }))







#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f)


#define __WCOREDUMP(status) ((status) & __WCOREFLAG)


#define __W_EXITCODE(ret,sig) ((ret) << 8 | (sig))
#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
#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))




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

extern int atoi (__const char *__nptr) throw () __attribute__ ((__pure__));

extern long int atol (__const char *__nptr) throw () __attribute__ ((__pure__));





__extension__ extern long long int atoll (__const char *__nptr)
     throw () __attribute__ ((__pure__));





extern double strtod (__const char *__restrict __nptr,
                      char **__restrict __endptr) throw ();





extern float strtof (__const char *__restrict __nptr,
                     char **__restrict __endptr) throw ();

extern long double strtold (__const char *__restrict __nptr,
                            char **__restrict __endptr) throw ();





extern long int strtol (__const char *__restrict __nptr,
                        char **__restrict __endptr, int __base) throw ();

extern unsigned long int strtoul (__const char *__restrict __nptr,
                                  char **__restrict __endptr, int __base)
     throw ();




__extension__
extern long long int strtoq (__const char *__restrict __nptr,
                             char **__restrict __endptr, int __base) throw ();

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
                                       char **__restrict __endptr, int __base)
     throw ();





__extension__
extern long long int strtoll (__const char *__restrict __nptr,
                              char **__restrict __endptr, int __base) throw ();

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
                                        char **__restrict __endptr, int __base)
     throw ();

# 229 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (__const char *__restrict __nptr,
                          char **__restrict __endptr, int __base,
                          __locale_t __loc) throw ();

extern unsigned long int strtoul_l (__const char *__restrict __nptr,
                                    char **__restrict __endptr,
                                    int __base, __locale_t __loc) throw ();

__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
                                char **__restrict __endptr, int __base,
                                __locale_t __loc) throw ();

__extension__
extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
                                          char **__restrict __endptr,
                                          int __base, __locale_t __loc)
     throw ();

extern double strtod_l (__const char *__restrict __nptr,
                        char **__restrict __endptr, __locale_t __loc)
     throw ();

extern float strtof_l (__const char *__restrict __nptr,
                       char **__restrict __endptr, __locale_t __loc) throw ();

extern long double strtold_l (__const char *__restrict __nptr,
                              char **__restrict __endptr,
                              __locale_t __loc) throw ();






extern double __strtod_internal (__const char *__restrict __nptr,
                                 char **__restrict __endptr, int __group)
     throw ();
extern float __strtof_internal (__const char *__restrict __nptr,
                                char **__restrict __endptr, int __group)
     throw ();
extern long double __strtold_internal (__const char *__restrict __nptr,
                                       char **__restrict __endptr,
                                       int __group) throw ();

extern long int __strtol_internal (__const char *__restrict __nptr,
                                   char **__restrict __endptr,
                                   int __base, int __group) throw ();
#define __strtol_internal_defined 1


extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
                                             char **__restrict __endptr,
                                             int __base, int __group) throw ();
#define __strtoul_internal_defined 1



__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
                                         char **__restrict __endptr,
                                         int __base, int __group) throw ();
#define __strtoll_internal_defined 1


__extension__
extern unsigned long long int __strtoull_internal (__const char *
                                                   __restrict __nptr,
                                                   char **__restrict __endptr,
                                                   int __base, int __group)
     throw ();
#define __strtoull_internal_defined 1







extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base) throw ()
{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}




extern __inline float
strtof (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtof_internal (__nptr, __endptr, 0);
}
extern __inline long double
strtold (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtold_internal (__nptr, __endptr, 0);
}




__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base) throw ()
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr,
          int __base) throw ()
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




extern __inline double
atof (__const char *__nptr) throw ()
{
  return strtod (__nptr, (char **) __null);
}
extern __inline int
atoi (__const char *__nptr) throw ()
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline long int
atol (__const char *__nptr) throw ()
{
  return strtol (__nptr, (char **) __null, 10);
}




__extension__ extern __inline long long int
atoll (__const char *__nptr) throw ()
{
  return strtoll (__nptr, (char **) __null, 10);
}

# 408 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw ();


extern long int a64l (__const char *__s) throw () __attribute__ ((__pure__));




# 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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 184 "/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
# 26 "/usr/include/bits/select.h" 3 4
#define __FD_ZERO(fdsp) do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (fd_set) / sizeof (__fd_mask)), "1" (&__FDS_BITS (fdsp)[0]) : "memory"); } while (0)
# 37 "/usr/include/bits/select.h" 3 4
#define __FD_SET(fd,fdsp) __asm__ __volatile__ ("btsl %1,%0" : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) : "r" (((int) (fd)) % __NFDBITS) : "cc","memory")




#define __FD_CLR(fd,fdsp) __asm__ __volatile__ ("btrl %1,%0" : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) : "r" (((int) (fd)) % __NFDBITS) : "cc","memory")




#define __FD_ISSET(fd,fdsp) (__extension__ ({register char __result; __asm__ __volatile__ ("btl %1,%2 ; setcb %b0" : "=q" (__result) : "r" (((int) (fd)) % __NFDBITS), "m" (__FDS_BITS (fdsp)[__FDELT (fd)]) : "cc"); __result; }))
# 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;






#define __NFDBITS (8 * sizeof (__fd_mask))
#define __FDELT(d) ((d) / __NFDBITS)
#define __FDMASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS))


typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * 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);


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


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 21 "/usr/include/sys/sysmacros.h" 3 4
#define _SYS_SYSMACROS_H 1







__extension__
extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
                                                        unsigned int __minor)
     throw ();


__extension__ extern __inline unsigned int
gnu_dev_major (unsigned long long int __dev) throw ()
{
  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
}

__extension__ extern __inline unsigned int
gnu_dev_minor (unsigned long long int __dev) throw ()
{
  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
}

__extension__ extern __inline unsigned long long int
gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
{
  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
          | (((unsigned long long int) (__minor & ~0xff)) << 12)
          | (((unsigned long long int) (__major & ~0xfff)) << 32));
}




#define major(dev) gnu_dev_major (dev)
#define minor(dev) gnu_dev_minor (dev)
#define makedev(maj,min) gnu_dev_makedev (maj, min)
# 220 "/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 
# 258 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;





# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 267 "/usr/include/sys/types.h" 2 3 4


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



extern char *setstate (char *__statebuf) throw ();







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

extern int srandom_r (unsigned int __seed, struct random_data *__buf) throw ();

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
                        size_t __statelen,
                        struct random_data *__restrict __buf) throw ();

extern int setstate_r (char *__restrict __statebuf,
                       struct random_data *__restrict __buf) throw ();






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


extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3]) throw ();


extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3]) throw ();


extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3]) throw ();
extern void lcong48 (unsigned short int __param[7]) throw ();





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 ();
extern int erand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      double *__restrict __result) throw ();


extern int lrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();
extern int nrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();


extern int mrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();
extern int jrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     throw ();

extern int seed48_r (unsigned short int __seed16v[3],
                     struct drand48_data *__buffer) throw ();

extern int lcong48_r (unsigned short int __param[7],
                      struct drand48_data *__buffer) throw ();






#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__ ((__malloc__));

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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {





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


#define alloca(size) __builtin_alloca (size)


}
# 579 "/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__ ((__malloc__));




extern void abort (void) throw () __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) throw ();





extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     throw ();






extern void exit (int __status) throw () __attribute__ ((__noreturn__));






extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));






extern char *getenv (__const char *__name) throw ();




extern char *__secure_getenv (__const char *__name) throw ();





extern int putenv (char *__string) throw ();





extern int setenv (__const char *__name, __const char *__value, int __replace)
     throw ();


extern int unsetenv (__const char *__name) throw ();






extern int clearenv (void) throw ();
# 663 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw ();
# 674 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template);
# 683 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template);
# 693 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw ();








extern int system (__const char *__command);







extern char *canonicalize_file_name (__const char *__name) throw ();
# 720 "/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;






extern void *bsearch (__const void *__key, __const void *__base,
                      size_t __nmemb, size_t __size, __compar_fn_t __compar);



extern void qsort (void *__base, size_t __nmemb, size_t __size,
                   __compar_fn_t __compar);



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

# 784 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) throw ();




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




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




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




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) throw ();
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) throw ();

extern int qecvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) throw ();
extern int qfcvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) throw ();







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 ();
# 866 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
                      char *__const *__restrict __tokens,
                      char **__restrict __valuep) throw ();





extern void setkey (__const char *__key) throw ();







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


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem) throw ();





}
# 53 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdlib" 2 3
# 84 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdlib" 3
namespace std
{
  using ::div_t;
  using ::ldiv_t;

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

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

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

  using ::wcstombs;
  using ::wctomb;


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

  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }
}
# 140 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdlib" 3
namespace __gnu_cxx
{

  using ::lldiv_t;





  using ::_Exit;


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

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


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

  inline lldiv_t
  lldiv(long long __n, long long __d)
  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
# 176 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cstdlib" 3
  using ::atoll;
  using ::strtoll;
  using ::strtoull;

  using ::strtof;
  using ::strtold;
}

namespace std
{

  using __gnu_cxx::lldiv_t;

  using __gnu_cxx::_Exit;
  using __gnu_cxx::abs;
  using __gnu_cxx::llabs;

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

  using __gnu_cxx::atoll;
  using __gnu_cxx::strtof;
  using __gnu_cxx::strtoll;
  using __gnu_cxx::strtoull;
  using __gnu_cxx::strtold;
}
# 68 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/new" 1 3
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/new" 3
#define __NEW__ 




extern "C++" {

namespace std
{





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


    virtual ~bad_alloc() throw();
  };

  struct nothrow_t { };
  extern const nothrow_t nothrow;


  typedef void (*new_handler)();

  new_handler set_new_handler(new_handler) throw();
}
# 82 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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() { };

}
# 70 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_pair.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_pair.h" 3
#define __GLIBCPP_INTERNAL_PAIR_H 

namespace std
{


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

  _T1 first;
  _T2 second;




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




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


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


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


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


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


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


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


template <class _T1, class _T2>
inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return !(__x < __y);
}
# 140 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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);
}

}
# 72 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/type_traits.h" 1 3
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/type_traits.h" 3
#define _CPP_BITS_TYPE_TRAITS_H 1

       
# 53 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/type_traits.h" 3
# 90 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/type_traits.h" 3
struct __true_type {};
struct __false_type {};

template <class _Tp>
struct __type_traits {
   typedef __true_type this_dummy_member_must_be_first;
# 113 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/type_traits.h" 3
   typedef __false_type has_trivial_default_constructor;
   typedef __false_type has_trivial_copy_constructor;
   typedef __false_type has_trivial_assignment_operator;
   typedef __false_type has_trivial_destructor;
   typedef __false_type is_POD_type;
};




template<> struct __type_traits<bool> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<signed char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<wchar_t> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<short> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned short> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<int> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned int> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<long long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned long long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<float> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<double> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<long double> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template <class _Tp>
struct __type_traits<_Tp*> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};





template <class _Tp> struct _Is_integer {
  typedef __false_type _Integral;
};

template<> struct _Is_integer<bool> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<signed char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<wchar_t> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<short> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned short> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<int> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned int> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<long> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned long> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<long long> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned long long> {
  typedef __true_type _Integral;
};

template<typename _Tp> struct _Is_normal_iterator {
   typedef __false_type _Normal;
};


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

template<typename _Iterator, typename _Container>
struct _Is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, _Container> > {
   typedef __true_type _Normal;
};
# 73 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_types.h" 1 3
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_types.h" 3
#define __GLIBCPP_INTERNAL_ITERATOR_BASE_TYPES_H 

       
# 68 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_types.h" 3

namespace std
{
# 80 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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(); }

}
# 74 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_funcs.h" 1 3
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_funcs.h" 3
#define __GLIBCPP_INTERNAL_ITERATOR_BASE_FUNCS_H 

       
# 68 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_funcs.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/concept_check.h" 1 3
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/concept_check.h" 3
#define _GLIBCPP_CONCEPT_CHECK 1

       
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/concept_check.h" 3
# 52 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/concept_check.h" 3
#define __glibcpp_function_requires(...) 
#define __glibcpp_class_requires(_a,_b) 
#define __glibcpp_class_requires2(_a,_b,_c) 
#define __glibcpp_class_requires3(_a,_b,_c,_d) 
#define __glibcpp_class_requires4(_a,_b,_c,_d,_e) 
# 69 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_funcs.h" 2 3

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

     

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

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

     
      return __last - __first;
    }
# 109 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator>
    inline typename iterator_traits<_InputIterator>::difference_type
    distance(_InputIterator __first, _InputIterator __last)
    {

      return __distance(__first, __last, __iterator_category(__first));
    }

  template<typename _InputIter, typename _Distance>
    inline void
    __advance(_InputIter& __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;
    }
# 162 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    inline void
    advance(_InputIterator& __i, _Distance __n)
    {

      __advance(__i, __n, __iterator_category(__i));
    }
}
# 75 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 1 3
# 66 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 3
#define __GLIBCPP_INTERNAL_ITERATOR_H 

namespace std
{
# 89 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
    };
# 272 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
# 332 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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) { }
# 358 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
        container->push_back(__value);
        return *this;
      }


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


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


      back_insert_iterator
      operator++(int) { return *this; }
    };
# 389 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 3
  template<typename _Container>
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 404 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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) { }
# 429 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
        container->push_front(__value);
        return *this;
      }


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


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


      front_insert_iterator
      operator++(int) { return *this; }
    };
# 460 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 3
  template<typename _Container>
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 479 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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) {}
# 521 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 3
      insert_iterator&
      operator=(const typename _Container::const_reference __value)
      {
        iter = container->insert(iter, __value);
        ++iter;
        return *this;
      }


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


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


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

namespace __gnu_cxx
{







  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
      : 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 _M_current;

    public:
      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>
      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __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; }
    };
# 654 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
             const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

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

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

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


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

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

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

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

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

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

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

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





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

  template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
            const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
}
# 76 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 2 3


namespace std
{
# 91 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _ForwardIter1, typename _ForwardIter2>
    inline void
    iter_swap(_ForwardIter1 __a, _ForwardIter2 __b)
    {
      typedef typename iterator_traits<_ForwardIter1>::value_type _ValueType1;
      typedef typename iterator_traits<_ForwardIter2>::value_type _ValueType2;


     
     
     
     

      _ValueType1 __tmp = *__a;
      *__a = *__b;
      *__b = __tmp;
    }
# 118 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline void
    swap(_Tp& __a, _Tp& __b)
    {

     

      _Tp __tmp = __a;
      __a = __b;
      __b = __tmp;
    }
# 146 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 166 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 186 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 204 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 221 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    __copy(_InputIter __first, _InputIter __last,
           _OutputIter __result,
           input_iterator_tag)
    {
      for ( ; __first != __last; ++__result, ++__first)
        *__result = *__first;
      return __result;
    }

  template<typename _RandomAccessIter, typename _OutputIter>
    inline _OutputIter
    __copy(_RandomAccessIter __first, _RandomAccessIter __last,
           _OutputIter __result,
           random_access_iterator_tag)
    {
      typedef typename iterator_traits<_RandomAccessIter>::difference_type
          _Distance;
      for (_Distance __n = __last - __first; __n > 0; --__n) {
        *__result = *__first;
        ++__first;
        ++__result;
      }
      return __result;
    }

  template<typename _Tp>
    inline _Tp*
    __copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result)
    {
      memmove(__result, __first, sizeof(_Tp) * (__last - __first));
      return __result + (__last - __first);
    }

  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    __copy_aux2(_InputIter __first, _InputIter __last,
                _OutputIter __result, __false_type)
    { return __copy(__first, __last, __result, __iterator_category(__first)); }

  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    __copy_aux2(_InputIter __first, _InputIter __last,
                _OutputIter __result, __true_type)
    { return __copy(__first, __last, __result, __iterator_category(__first)); }

  template<typename _Tp>
    inline _Tp*
    __copy_aux2(_Tp* __first, _Tp* __last,
                _Tp* __result, __true_type)
    { return __copy_trivial(__first, __last, __result); }

  template<typename _Tp>
    inline _Tp*
    __copy_aux2(const _Tp* __first, const _Tp* __last,
                _Tp* __result, __true_type)
    { return __copy_trivial(__first, __last, __result); }

  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    __copy_ni2(_InputIter __first, _InputIter __last,
               _OutputIter __result, __true_type)
    {
      typedef typename iterator_traits<_InputIter>::value_type
          _ValueType;
      typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
          _Trivial;
      return _OutputIter(__copy_aux2(__first, __last,
                                     __result.base(),
                                     _Trivial()));
    }

  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    __copy_ni2(_InputIter __first, _InputIter __last,
               _OutputIter __result, __false_type)
    {
      typedef typename iterator_traits<_InputIter>::value_type
          _ValueType;
      typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
          _Trivial;
      return __copy_aux2(__first, __last,
                         __result,
                         _Trivial());
    }

  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    __copy_ni1(_InputIter __first, _InputIter __last,
               _OutputIter __result, __true_type)
    {
      typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
      return __copy_ni2(__first.base(), __last.base(), __result, __Normal());
    }

  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    __copy_ni1(_InputIter __first, _InputIter __last,
               _OutputIter __result, __false_type)
    {
      typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
      return __copy_ni2(__first, __last, __result, __Normal());
    }
# 339 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    copy(_InputIter __first, _InputIter __last, _OutputIter __result)
    {

     
     


       typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal;
       return __copy_ni1(__first, __last, __result, __Normal());
    }




  template<typename _BidirectionalIter1, typename _BidirectionalIter2>
    inline _BidirectionalIter2
    __copy_backward(_BidirectionalIter1 __first, _BidirectionalIter1 __last,
                    _BidirectionalIter2 __result,
                    bidirectional_iterator_tag)
    {
      while (__first != __last)
        *--__result = *--__last;
      return __result;
    }

  template<typename _RandomAccessIter, typename _BidirectionalIter>
    inline _BidirectionalIter
    __copy_backward(_RandomAccessIter __first, _RandomAccessIter __last,
                    _BidirectionalIter __result,
                    random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIter>::difference_type __n;
      for (__n = __last - __first; __n > 0; --__n)
        *--__result = *--__last;
      return __result;
    }







  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
           typename _BoolType>
    struct __copy_backward_dispatch
    {
      static _BidirectionalIter2
      copy(_BidirectionalIter1 __first, _BidirectionalIter1 __last,
           _BidirectionalIter2 __result)
      {
        return __copy_backward(__first, __last,
                               __result,
                               __iterator_category(__first));
      }
    };

  template<typename _Tp>
    struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
    {
      static _Tp*
      copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
      {
        const ptrdiff_t _Num = __last - __first;
        memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
        return __result - _Num;
      }
    };

  template<typename _Tp>
    struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type>
    {
      static _Tp*
      copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
      {
        return __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
          ::copy(__first, __last, __result);
      }
    };

  template<typename _BI1, typename _BI2>
    inline _BI2
    __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
                            ::has_trivial_assignment_operator _Trivial;
      return __copy_backward_dispatch<_BI1, _BI2, _Trivial>
                  ::copy(__first, __last, __result);
    }

  template <typename _BI1, typename _BI2>
    inline _BI2
    __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
                                           _BI2 __result, __true_type)
    { return _BI2(__copy_backward_aux(__first, __last, __result.base())); }

  template <typename _BI1, typename _BI2>
    inline _BI2
    __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
                                           _BI2 __result, __false_type)
    { return __copy_backward_aux(__first, __last, __result); }

  template <typename _BI1, typename _BI2>
    inline _BI2
    __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
                                          _BI2 __result, __true_type)
    {
      typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
      return __copy_backward_output_normal_iterator(__first.base(), __last.base(),
                                                    __result, __Normal());
    }

  template <typename _BI1, typename _BI2>
    inline _BI2
    __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
                                          _BI2 __result, __false_type)
    {
      typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
      return __copy_backward_output_normal_iterator(__first, __last, __result,
                                                    __Normal());
    }
# 477 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template <typename _BI1, typename _BI2>
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {

     
     
     



      typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
      return __copy_backward_input_normal_iterator(__first, __last, __result,
                                                   __Normal());
    }
# 509 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _ForwardIter, typename _Tp>
    void
    fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value)
    {

     

      for ( ; __first != __last; ++__first)
        *__first = __value;
    }
# 531 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _OutputIter, typename _Size, typename _Tp>
    _OutputIter
    fill_n(_OutputIter __first, _Size __n, const _Tp& __value)
    {

     

      for ( ; __n > 0; --__n, ++__first)
        *__first = __value;
      return __first;
    }



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

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

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

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

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

  template<typename _Size>
    inline char*
    fill_n(char* __first, _Size __n, const char& __c)
    {
      fill(__first, __first + __n, __c);
      return __first + __n;
    }
# 606 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2>
    pair<_InputIter1, _InputIter2>
    mismatch(_InputIter1 __first1, _InputIter1 __last1,
             _InputIter2 __first2)
    {

     
     
     

     


      while (__first1 != __last1 && *__first1 == *__first2) {
        ++__first1;
        ++__first2;
      }
      return pair<_InputIter1, _InputIter2>(__first1, __first2);
    }
# 640 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _BinaryPredicate>
    pair<_InputIter1, _InputIter2>
    mismatch(_InputIter1 __first1, _InputIter1 __last1,
             _InputIter2 __first2,
             _BinaryPredicate __binary_pred)
    {

     
     

      while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
        ++__first1;
        ++__first2;
      }
      return pair<_InputIter1, _InputIter2>(__first1, __first2);
    }
# 668 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2>
    inline bool
    equal(_InputIter1 __first1, _InputIter1 __last1,
          _InputIter2 __first2)
    {

     
     
     



      for ( ; __first1 != __last1; ++__first1, ++__first2)
        if (!(*__first1 == *__first2))
          return false;
      return true;
    }
# 699 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _BinaryPredicate>
    inline bool
    equal(_InputIter1 __first1, _InputIter1 __last1,
          _InputIter2 __first2,
          _BinaryPredicate __binary_pred)
    {

     
     

      for ( ; __first1 != __last1; ++__first1, ++__first2)
        if (!__binary_pred(*__first1, *__first2))
          return false;
      return true;
    }
# 732 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2>
    bool
    lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
                            _InputIter2 __first2, _InputIter2 __last2)
    {

     
     
     

     


      for ( ; __first1 != __last1 && __first2 != __last2
            ; ++__first1, ++__first2) {
        if (*__first1 < *__first2)
          return true;
        if (*__first2 < *__first1)
          return false;
      }
      return __first1 == __last1 && __first2 != __last2;
    }
# 767 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _Compare>
    bool
    lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
                            _InputIter2 __first2, _InputIter2 __last2,
                            _Compare __comp)
    {

     
     

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

  inline bool
  lexicographical_compare(const unsigned char* __first1, const unsigned char* __last1,
                          const unsigned char* __first2, const unsigned char* __last2)
  {
    const size_t __len1 = __last1 - __first1;
    const size_t __len2 = __last2 - __first2;
    const int __result = memcmp(__first1, __first2, min(__len1, __len2));
    return __result != 0 ? __result < 0 : __len1 < __len2;
  }

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

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






  }

}
# 55 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 1 3
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
#define __GLIBCPP_INTERNAL_ALLOC_H 
# 88 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 3
#define __throw_exception_again throw
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 89 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_threads.h" 1 3
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_threads.h" 3
#define __SGI_STL_INTERNAL_THREADS_H 




namespace std
{




  struct _Refcount_Base
  {

    typedef size_t _RC_t;


    volatile _RC_t _M_ref_count;


    __gthread_mutex_t _M_ref_count_lock;

    _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
    {

      __gthread_mutex_t __tmp = {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, { 0, 0 }};
      _M_ref_count_lock = __tmp;





    }

    void
    _M_incr()
    {
      __gthread_mutex_lock(&_M_ref_count_lock);
      ++_M_ref_count;
      __gthread_mutex_unlock(&_M_ref_count_lock);
    }

    _RC_t
    _M_decr()
    {
      __gthread_mutex_lock(&_M_ref_count_lock);
      volatile _RC_t __tmp = --_M_ref_count;
      __gthread_mutex_unlock(&_M_ref_count_lock);
      return __tmp;
    }
  };
# 109 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_threads.h" 3
  template<int __dummy>
    struct _Swap_lock_struct
    { static __gthread_mutex_t _S_swap_lock; };

  template<int __dummy>
    __gthread_mutex_t
    _Swap_lock_struct<__dummy>::_S_swap_lock = {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, { 0, 0 }};



  inline unsigned long
  _Atomic_swap(unsigned long * __p, unsigned long __q)
  {
    __gthread_mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
    unsigned long __result = *__p;
    *__p = __q;
    __gthread_mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
    return __result;
  }

}
# 155 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_threads.h" 3
namespace std
{
  struct _STL_mutex_lock
  {





    __gthread_mutex_t _M_lock;

    void
    _M_initialize()
    {
# 192 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_threads.h" 3
    }

    void
    _M_acquire_lock()
    {



      __gthread_mutex_lock(&_M_lock);
    }

    void
    _M_release_lock()
    {



      __gthread_mutex_unlock(&_M_lock);
    }
  };


#define __STL_MUTEX_INITIALIZER = { __GTHREAD_MUTEX_INIT }
# 228 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_threads.h" 3
  struct _STL_auto_lock
  {
    _STL_mutex_lock& _M_lock;

    _STL_auto_lock(_STL_mutex_lock& __lock) : _M_lock(__lock)
    { _M_lock._M_acquire_lock(); }

    ~_STL_auto_lock() { _M_lock._M_release_lock(); }

  private:
    void operator=(const _STL_auto_lock&);
    _STL_auto_lock(const _STL_auto_lock&);
  };

}
# 90 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 2 3



namespace std
{
# 103 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  class __new_alloc
  {
  public:
    static void*
    allocate(size_t __n)
    { return ::operator new(__n); }

    static void
    deallocate(void* __p, size_t)
    { ::operator delete(__p); }
  };
# 126 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  template<int __inst>
    class __malloc_alloc_template
    {
    private:
      static void* _S_oom_malloc(size_t);
      static void* _S_oom_realloc(void*, size_t);
      static void (* __malloc_alloc_oom_handler)();

    public:
      static void*
      allocate(size_t __n)
      {
        void* __result = malloc(__n);
        if (__builtin_expect(__result == 0, 0))
          __result = _S_oom_malloc(__n);
        return __result;
      }

      static void
      deallocate(void* __p, size_t )
      { free(__p); }

      static void*
      reallocate(void* __p, size_t , size_t __new_sz)
      {
        void* __result = realloc(__p, __new_sz);
        if (__builtin_expect(__result == 0, 0))
          __result = _S_oom_realloc(__p, __new_sz);
        return __result;
      }

      static void (* __set_malloc_handler(void (*__f)()))()
      {
        void (* __old)() = __malloc_alloc_oom_handler;
        __malloc_alloc_oom_handler = __f;
        return __old;
      }
    };


  template<int __inst>
    void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;

  template<int __inst>
    void*
    __malloc_alloc_template<__inst>::
    _S_oom_malloc(size_t __n)
    {
      void (* __my_malloc_handler)();
      void* __result;

      for (;;)
        {
          __my_malloc_handler = __malloc_alloc_oom_handler;
          if (__builtin_expect(__my_malloc_handler == 0, 0))
            __throw_bad_alloc();
          (*__my_malloc_handler)();
          __result = malloc(__n);
          if (__result)
            return __result;
        }
    }

  template<int __inst>
    void*
    __malloc_alloc_template<__inst>::
    _S_oom_realloc(void* __p, size_t __n)
    {
      void (* __my_malloc_handler)();
      void* __result;

      for (;;)
        {
          __my_malloc_handler = __malloc_alloc_oom_handler;
          if (__builtin_expect(__my_malloc_handler == 0, 0))
            __throw_bad_alloc();
          (*__my_malloc_handler)();
          __result = realloc(__p, __n);
          if (__result)
            return __result;
        }
    }


  typedef __new_alloc __mem_interface;
# 223 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  template<typename _Tp, typename _Alloc>
    class __simple_alloc
    {
    public:
      static _Tp*
      allocate(size_t __n)
      {
        _Tp* __ret = 0;
        if (__n)
          __ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
        return __ret;
      }

      static _Tp*
      allocate()
      { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }

      static void
      deallocate(_Tp* __p, size_t __n)
      { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }

      static void
      deallocate(_Tp* __p)
      { _Alloc::deallocate(__p, sizeof (_Tp)); }
    };
# 261 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  template<typename _Alloc>
    class __debug_alloc
    {
    private:


      enum {_S_extra = 8};

    public:
      static void*
      allocate(size_t __n)
      {
        char* __result = (char*)_Alloc::allocate(__n + (int) _S_extra);
        *(size_t*)__result = __n;
        return __result + (int) _S_extra;
      }

      static void
      deallocate(void* __p, size_t __n)
      {
        char* __real_p = (char*)__p - (int) _S_extra;
        if (*(size_t*)__real_p != __n)
          abort();
        _Alloc::deallocate(__real_p, __n + (int) _S_extra);
      }

      static void*
      reallocate(void* __p, size_t __old_sz, size_t __new_sz)
      {
        char* __real_p = (char*)__p - (int) _S_extra;
        if (*(size_t*)__real_p != __old_sz)
          abort();
        char* __result = (char*) _Alloc::reallocate(__real_p,
                                                    __old_sz + (int) _S_extra,
                                                    __new_sz + (int) _S_extra);
        *(size_t*)__result = __new_sz;
        return __result + (int) _S_extra;
      }
    };
# 332 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  template<bool __threads, int __inst>
    class __default_alloc_template
    {
    private:
      enum {_ALIGN = 8};
      enum {_MAX_BYTES = 128};
      enum {_NFREELISTS = _MAX_BYTES / _ALIGN};

      union _Obj
      {
        union _Obj* _M_free_list_link;
        char _M_client_data[1];
      };

      static _Obj* volatile _S_free_list[_NFREELISTS];


      static char* _S_start_free;
      static char* _S_end_free;
      static size_t _S_heap_size;

      static _STL_mutex_lock _S_node_allocator_lock;

      static size_t
      _S_round_up(size_t __bytes)
      { return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }

      static size_t
      _S_freelist_index(size_t __bytes)
      { return (((__bytes) + (size_t)_ALIGN - 1)/(size_t)_ALIGN - 1); }



      static void*
      _S_refill(size_t __n);



      static char*
      _S_chunk_alloc(size_t __size, int& __nobjs);



      struct _Lock
      {
        _Lock() { if (__threads) _S_node_allocator_lock._M_acquire_lock(); }
        ~_Lock() { if (__threads) _S_node_allocator_lock._M_release_lock(); }
      } __attribute__ ((__unused__));
      friend struct _Lock;

      static _Atomic_word _S_force_new;

    public:

      static void*
      allocate(size_t __n)
      {
        void* __ret = 0;




        if (_S_force_new == 0)
          {
            if (getenv("GLIBCPP_FORCE_NEW"))
              __atomic_add(&_S_force_new, 1);
            else
              __atomic_add(&_S_force_new, -1);
          }

        if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0))
          __ret = __new_alloc::allocate(__n);
        else
          {
            _Obj* volatile* __my_free_list = _S_free_list
              + _S_freelist_index(__n);



            _Lock __lock_instance;
            _Obj* __restrict__ __result = *__my_free_list;
            if (__builtin_expect(__result == 0, 0))
              __ret = _S_refill(_S_round_up(__n));
            else
              {
                *__my_free_list = __result -> _M_free_list_link;
                __ret = __result;
              }
            if (__builtin_expect(__ret == 0, 0))
              __throw_bad_alloc();
          }
        return __ret;
      }


      static void
      deallocate(void* __p, size_t __n)
      {
        if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0))
          __new_alloc::deallocate(__p, __n);
        else
          {
            _Obj* volatile* __my_free_list = _S_free_list
              + _S_freelist_index(__n);
            _Obj* __q = (_Obj*)__p;




            _Lock __lock_instance;
            __q -> _M_free_list_link = *__my_free_list;
            *__my_free_list = __q;
          }
      }

      static void*
      reallocate(void* __p, size_t __old_sz, size_t __new_sz);
    };

  template<bool __threads, int __inst> _Atomic_word
  __default_alloc_template<__threads, __inst>::_S_force_new = 0;

  template<bool __threads, int __inst>
    inline bool
    operator==(const __default_alloc_template<__threads,__inst>&,
               const __default_alloc_template<__threads,__inst>&)
    { return true; }

  template<bool __threads, int __inst>
    inline bool
    operator!=(const __default_alloc_template<__threads,__inst>&,
               const __default_alloc_template<__threads,__inst>&)
    { return false; }





  template<bool __threads, int __inst>
    char*
    __default_alloc_template<__threads, __inst>::
    _S_chunk_alloc(size_t __size, int& __nobjs)
    {
      char* __result;
      size_t __total_bytes = __size * __nobjs;
      size_t __bytes_left = _S_end_free - _S_start_free;

      if (__bytes_left >= __total_bytes)
        {
          __result = _S_start_free;
          _S_start_free += __total_bytes;
          return __result ;
        }
      else if (__bytes_left >= __size)
        {
          __nobjs = (int)(__bytes_left/__size);
          __total_bytes = __size * __nobjs;
          __result = _S_start_free;
          _S_start_free += __total_bytes;
          return __result;
        }
      else
        {
          size_t __bytes_to_get =
            2 * __total_bytes + _S_round_up(_S_heap_size >> 4);

          if (__bytes_left > 0)
            {
              _Obj* volatile* __my_free_list =
                _S_free_list + _S_freelist_index(__bytes_left);

              ((_Obj*)(void*)_S_start_free) -> _M_free_list_link = *__my_free_list;
              *__my_free_list = (_Obj*)(void*)_S_start_free;
            }
          _S_start_free = (char*) __new_alloc::allocate(__bytes_to_get);
          if (_S_start_free == 0)
            {
              size_t __i;
              _Obj* volatile* __my_free_list;
              _Obj* __p;



              __i = __size;
              for (; __i <= (size_t) _MAX_BYTES; __i += (size_t) _ALIGN)
                {
                  __my_free_list = _S_free_list + _S_freelist_index(__i);
                  __p = *__my_free_list;
                  if (__p != 0)
                    {
                      *__my_free_list = __p -> _M_free_list_link;
                      _S_start_free = (char*)__p;
                      _S_end_free = _S_start_free + __i;
                      return _S_chunk_alloc(__size, __nobjs);


                    }
                }
              _S_end_free = 0;
              _S_start_free = (char*)__new_alloc::allocate(__bytes_to_get);


            }
          _S_heap_size += __bytes_to_get;
          _S_end_free = _S_start_free + __bytes_to_get;
          return _S_chunk_alloc(__size, __nobjs);
        }
    }





  template<bool __threads, int __inst>
    void*
    __default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
    {
      int __nobjs = 20;
      char* __chunk = _S_chunk_alloc(__n, __nobjs);
      _Obj* volatile* __my_free_list;
      _Obj* __result;
      _Obj* __current_obj;
      _Obj* __next_obj;
      int __i;

      if (1 == __nobjs)
        return __chunk;
      __my_free_list = _S_free_list + _S_freelist_index(__n);


      __result = (_Obj*)(void*)__chunk;
      *__my_free_list = __next_obj = (_Obj*)(void*)(__chunk + __n);
      for (__i = 1; ; __i++)
        {
          __current_obj = __next_obj;
          __next_obj = (_Obj*)(void*)((char*)__next_obj + __n);
          if (__nobjs - 1 == __i)
            {
              __current_obj -> _M_free_list_link = 0;
              break;
            }
          else
            __current_obj -> _M_free_list_link = __next_obj;
        }
      return __result;
    }


  template<bool threads, int inst>
    void*
    __default_alloc_template<threads, inst>::
    reallocate(void* __p, size_t __old_sz, size_t __new_sz)
    {
      void* __result;
      size_t __copy_sz;

      if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES)
        return(realloc(__p, __new_sz));
      if (_S_round_up(__old_sz) == _S_round_up(__new_sz))
        return(__p);
      __result = allocate(__new_sz);
      __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
      memcpy(__result, __p, __copy_sz);
      deallocate(__p, __old_sz);
      return __result;
    }

  template<bool __threads, int __inst>
    _STL_mutex_lock
    __default_alloc_template<__threads,__inst>::_S_node_allocator_lock
    = { {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, { 0, 0 }} };

  template<bool __threads, int __inst>
    char* __default_alloc_template<__threads,__inst>::_S_start_free = 0;

  template<bool __threads, int __inst>
    char* __default_alloc_template<__threads,__inst>::_S_end_free = 0;

  template<bool __threads, int __inst>
    size_t __default_alloc_template<__threads,__inst>::_S_heap_size = 0;

  template<bool __threads, int __inst>
    typename __default_alloc_template<__threads,__inst>::_Obj* volatile
    __default_alloc_template<__threads,__inst>::_S_free_list[_NFREELISTS];

  typedef __default_alloc_template<true,0> __alloc;
  typedef __default_alloc_template<false,0> __single_client_alloc;
# 635 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  template<typename _Tp>
    class allocator
    {
      typedef __alloc _Alloc;
    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&) throw() {}
      template<typename _Tp1>
        allocator(const allocator<_Tp1>&) throw() {}
      ~allocator() throw() {}

      pointer
      address(reference __x) const { return &__x; }

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



      _Tp*
      allocate(size_type __n, const void* = 0)
      {
        _Tp* __ret = 0;
        if (__n)
          {
            if (__n <= this->max_size())
              __ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
            else
              __throw_bad_alloc();
          }
        return __ret;
      }


      void
      deallocate(pointer __p, size_type __n)
      { _Alloc::deallocate(__p, __n * sizeof(_Tp)); }

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

      void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
      void destroy(pointer __p) { __p->~_Tp(); }
    };

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

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


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

  template<typename _T1, typename _T2>
    inline bool
    operator!=(const allocator<_T1>&, const allocator<_T2>&)
    { return false; }
# 731 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  template<typename _Tp, typename _Alloc>
    struct __allocator
    {
      _Alloc __underlying_alloc;

      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, _Alloc> other; };

      __allocator() throw() {}
      __allocator(const __allocator& __a) throw()
      : __underlying_alloc(__a.__underlying_alloc) {}

      template<typename _Tp1>
        __allocator(const __allocator<_Tp1, _Alloc>& __a) throw()
        : __underlying_alloc(__a.__underlying_alloc) {}

      ~__allocator() throw() {}

      pointer
      address(reference __x) const { return &__x; }

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



      _Tp*
      allocate(size_type __n, const void* = 0)
      {
        _Tp* __ret = 0;
        if (__n)
          __ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
        return __ret;
      }


      void
      deallocate(pointer __p, size_type __n)
      { __underlying_alloc.deallocate(__p, __n * sizeof(_Tp)); }

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

      void
      construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }

      void
      destroy(pointer __p) { __p->~_Tp(); }
    };

  template<typename _Alloc>
    struct __allocator<void, _Alloc>
    {
      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, _Alloc> other; };
    };

  template<typename _Tp, typename _Alloc>
    inline bool
    operator==(const __allocator<_Tp,_Alloc>& __a1,
               const __allocator<_Tp,_Alloc>& __a2)
    { return __a1.__underlying_alloc == __a2.__underlying_alloc; }

  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const __allocator<_Tp, _Alloc>& __a1,
               const __allocator<_Tp, _Alloc>& __a2)
    { return __a1.__underlying_alloc != __a2.__underlying_alloc; }







  template<int inst>
    inline bool
    operator==(const __malloc_alloc_template<inst>&,
               const __malloc_alloc_template<inst>&)
    { return true; }

  template<int __inst>
    inline bool
    operator!=(const __malloc_alloc_template<__inst>&,
               const __malloc_alloc_template<__inst>&)
    { return false; }

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

  template<typename _Alloc>
    inline bool
    operator!=(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&)
    { return false; }
# 884 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_alloc.h" 3
  template<typename _Tp, typename _Allocator>
    struct _Alloc_traits
    {
      static const bool _S_instanceless = false;
      typedef typename _Allocator::template rebind<_Tp>::other allocator_type;
    };

  template<typename _Tp, typename _Allocator>
    const bool _Alloc_traits<_Tp, _Allocator>::_S_instanceless;


  template<typename _Tp, typename _Tp1>
    struct _Alloc_traits<_Tp, allocator<_Tp1> >
    {
      static const bool _S_instanceless = true;
      typedef __simple_alloc<_Tp, __alloc> _Alloc_type;
      typedef allocator<_Tp> allocator_type;
    };




  template<typename _Tp, int __inst>
    struct _Alloc_traits<_Tp, __malloc_alloc_template<__inst> >
    {
      static const bool _S_instanceless = true;
      typedef __simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
      typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
    };

  template<typename _Tp, bool __threads, int __inst>
    struct _Alloc_traits<_Tp, __default_alloc_template<__threads, __inst> >
    {
      static const bool _S_instanceless = true;
      typedef __simple_alloc<_Tp, __default_alloc_template<__threads, __inst> >
      _Alloc_type;
      typedef __allocator<_Tp, __default_alloc_template<__threads, __inst> >
      allocator_type;
    };

  template<typename _Tp, typename _Alloc>
    struct _Alloc_traits<_Tp, __debug_alloc<_Alloc> >
    {
      static const bool _S_instanceless = true;
      typedef __simple_alloc<_Tp, __debug_alloc<_Alloc> > _Alloc_type;
      typedef __allocator<_Tp, __debug_alloc<_Alloc> > allocator_type;
    };





  template<typename _Tp, typename _Tp1, int __inst>
    struct _Alloc_traits<_Tp,
                         __allocator<_Tp1, __malloc_alloc_template<__inst> > >
    {
      static const bool _S_instanceless = true;
      typedef __simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
      typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
    };

  template<typename _Tp, typename _Tp1, bool __thr, int __inst>
    struct _Alloc_traits<_Tp, __allocator<_Tp1, __default_alloc_template<__thr, __inst> > >
    {
      static const bool _S_instanceless = true;
      typedef __simple_alloc<_Tp, __default_alloc_template<__thr,__inst> >
      _Alloc_type;
      typedef __allocator<_Tp, __default_alloc_template<__thr,__inst> >
      allocator_type;
    };

  template<typename _Tp, typename _Tp1, typename _Alloc>
    struct _Alloc_traits<_Tp, __allocator<_Tp1, __debug_alloc<_Alloc> > >
    {
      static const bool _S_instanceless = true;
      typedef __simple_alloc<_Tp, __debug_alloc<_Alloc> > _Alloc_type;
      typedef __allocator<_Tp, __debug_alloc<_Alloc> > allocator_type;
    };






  extern template class allocator<char>;
  extern template class allocator<wchar_t>;
  extern template class __default_alloc_template<true,0>;

}
# 56 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_construct.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_construct.h" 3
#define _CPP_BITS_STL_CONSTRUCT_H 1




namespace std
{






  template <class _T1, class _T2>
    inline void
    _Construct(_T1* __p, const _T2& __value)
    { new (static_cast<void*>(__p)) _T1(__value); }







  template <class _T1>
    inline void
    _Construct(_T1* __p)
    { new (static_cast<void*>(__p)) _T1(); }
# 98 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_construct.h" 3
  template <class _ForwardIterator>
    inline void
    __destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
    { for ( ; __first != __last; ++__first) _Destroy(&*__first); }
# 112 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_construct.h" 3
  template <class _ForwardIterator>
    inline void
    __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type)
    { }






  template <class _Tp>
    inline void
    _Destroy(_Tp* __pointer)
    { __pointer->~_Tp(); }
# 134 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_construct.h" 3
  template <class _ForwardIterator>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;
      typedef typename __type_traits<_Value_type>::has_trivial_destructor
                       _Has_trivial_destructor;

      __destroy_aux(__first, __last, _Has_trivial_destructor());
    }
}
# 57 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 2 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_uninitialized.h" 3
#define _CPP_BITS_STL_UNINITIALIZED_H 1



namespace std
{



  template<typename _InputIter, typename _ForwardIter>
    inline _ForwardIter
    __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
                             _ForwardIter __result,
                             __true_type)
    { return copy(__first, __last, __result); }

  template<typename _InputIter, typename _ForwardIter>
    _ForwardIter
    __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
                             _ForwardIter __result,
                             __false_type)
    {
      _ForwardIter __cur = __result;
      try {
        for ( ; __first != __last; ++__first, ++__cur)
          _Construct(&*__cur, *__first);
        return __cur;
      }
      catch(...)
        {
          _Destroy(__result, __cur);
          throw;
        }
    }
# 106 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_uninitialized.h" 3
  template<typename _InputIter, typename _ForwardIter>
    inline _ForwardIter
    uninitialized_copy(_InputIter __first, _InputIter __last, _ForwardIter __result)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
      return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
    }

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

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



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

  template<typename _ForwardIter, typename _Tp>
    void
    __uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
                             const _Tp& __x, __false_type)
    {
      _ForwardIter __cur = __first;
      try {
        for ( ; __cur != __last; ++__cur)
          _Construct(&*__cur, __x);
      }
      catch(...)
        {
          _Destroy(__first, __cur);
          throw;
        }
    }
# 164 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_uninitialized.h" 3
  template<typename _ForwardIter, typename _Tp>
    inline void
    uninitialized_fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
      __uninitialized_fill_aux(__first, __last, __x, _Is_POD());
    }



  template<typename _ForwardIter, typename _Size, typename _Tp>
    inline _ForwardIter
    __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
                               const _Tp& __x, __true_type)
    {
      return fill_n(__first, __n, __x);
    }

  template<typename _ForwardIter, typename _Size, typename _Tp>
    _ForwardIter
    __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
                               const _Tp& __x, __false_type)
    {
      _ForwardIter __cur = __first;
      try {
        for ( ; __n > 0; --__n, ++__cur)
          _Construct(&*__cur, __x);
        return __cur;
      }
      catch(...)
        {
          _Destroy(__first, __cur);
          throw;
        }
    }
# 210 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_uninitialized.h" 3
  template<typename _ForwardIter, typename _Size, typename _Tp>
    inline _ForwardIter
    uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
      return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
    }
# 227 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_uninitialized.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _ForwardIter>
    inline _ForwardIter
    __uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
                              _InputIter2 __first2, _InputIter2 __last2,
                              _ForwardIter __result)
    {
      _ForwardIter __mid = uninitialized_copy(__first1, __last1, __result);
      try {
        return uninitialized_copy(__first2, __last2, __mid);
      }
      catch(...)
        {
          _Destroy(__result, __mid);
          throw;
        }
    }




  template<typename _ForwardIter, typename _Tp, typename _InputIter>
    inline _ForwardIter
    __uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid,
                              const _Tp& __x,
                              _InputIter __first, _InputIter __last)
    {
      uninitialized_fill(__result, __mid, __x);
      try {
        return uninitialized_copy(__first, __last, __mid);
      }
      catch(...)
        {
          _Destroy(__result, __mid);
          throw;
        }
    }




  template<typename _InputIter, typename _ForwardIter, typename _Tp>
    inline void
    __uninitialized_copy_fill(_InputIter __first1, _InputIter __last1,
                              _ForwardIter __first2, _ForwardIter __last2,
                              const _Tp& __x)
    {
      _ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2);
      try {
        uninitialized_fill(__mid2, __last2, __x);
      }
      catch(...)
        {
          _Destroy(__first2, __mid2);
          throw;
        }
    }

}
# 59 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_raw_storage_iter.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_raw_storage_iter.h" 3
#define _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H 1

namespace std
{




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

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

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

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

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

      raw_storage_iterator<_ForwardIterator, _Tp>
      operator++(int)
      {
        raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
        ++_M_iter;
        return __tmp;
      }
    };
}
# 60 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 2 3

namespace std
{
# 71 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
  template<typename _Tp>
    pair<_Tp*, ptrdiff_t>
    __get_temporary_buffer(ptrdiff_t __len, _Tp*)
    {
      if (__len > ptrdiff_t(2147483647 / sizeof(_Tp)))
        __len = 2147483647 / sizeof(_Tp);

      while (__len > 0)
        {
          _Tp* __tmp = (_Tp*) std::malloc((std::size_t)__len * sizeof(_Tp));
          if (__tmp != 0)
            return pair<_Tp*, ptrdiff_t>(__tmp, __len);
          __len /= 2;
        }
      return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0);
    }
# 103 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
  template<typename _Tp>
    inline pair<_Tp*,ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len)
    { return __get_temporary_buffer(__len, (_Tp*) 0); }
# 115 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
  template<typename _Tp>
    void
    return_temporary_buffer(_Tp* __p)
    { std::free(__p); }
# 127 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    };
# 166 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:

      typedef _Tp element_type;







      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
# 192 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 203 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 214 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
        reset(__a.release());
        return *this;
      }
# 231 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
          reset(__a.release());
          return *this;
        }
# 251 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      ~auto_ptr() { delete _M_ptr; }
# 261 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      element_type&
      operator*() const throw() { return *_M_ptr; }







      element_type*
      operator->() const throw() { return _M_ptr; }
# 283 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 297 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      element_type*
      release() throw()
      {
        element_type* __tmp = _M_ptr;
        _M_ptr = 0;
        return __tmp;
      }
# 312 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      void
      reset(element_type* __p = 0) throw()
      {
        if (__p != _M_ptr)
          {
            delete _M_ptr;
            _M_ptr = __p;
          }
      }
# 333 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/memory" 3
      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
        if (__ref._M_ptr != this->get())
          {
            delete _M_ptr;
            _M_ptr = __ref._M_ptr;
          }
        return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }

  };
}
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 2 3



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 3
#define __GLIBCPP_INTERNAL_FUNCTION_H 

namespace std
{
# 101 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 3
template <class _Arg, class _Result>
struct unary_function {
  typedef _Arg argument_type;
  typedef _Result result_type;
};




template <class _Arg1, class _Arg2, class _Result>
struct binary_function {
  typedef _Arg1 first_argument_type;
  typedef _Arg2 second_argument_type;
  typedef _Result result_type;
};
# 127 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 3
template <class _Tp>
struct plus : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
};


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


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


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


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


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


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


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


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


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


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


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


template <class _Tp>
struct logical_not : public unary_function<_Tp,bool>
{
  bool operator()(const _Tp& __x) const { return !__x; }
};
# 271 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 3
template <class _Predicate>
class unary_negate
  : public unary_function<typename _Predicate::argument_type, bool> {
protected:
  _Predicate _M_pred;
public:
  explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::argument_type& __x) const {
    return !_M_pred(__x);
  }
};


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


template <class _Predicate>
class binary_negate
  : public binary_function<typename _Predicate::first_argument_type,
                           typename _Predicate::second_argument_type,
                           bool> {
protected:
  _Predicate _M_pred;
public:
  explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::first_argument_type& __x,
                  const typename _Predicate::second_argument_type& __y) const
  {
    return !_M_pred(__x, __y);
  }
};


template <class _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{
  return binary_negate<_Predicate>(__pred);
}
# 349 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 3
template <class _Operation>
class binder1st
  : public unary_function<typename _Operation::second_argument_type,
                          typename _Operation::result_type> {
protected:
  _Operation op;
  typename _Operation::first_argument_type value;
public:
  binder1st(const _Operation& __x,
            const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) {}
  typename _Operation::result_type
  operator()(const typename _Operation::second_argument_type& __x) const {
    return op(value, __x);
  }


  typename _Operation::result_type
  operator()(typename _Operation::second_argument_type& __x) const {
    return op(value, __x);
  }

};


template <class _Operation, class _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
  typedef typename _Operation::first_argument_type _Arg1_type;
  return binder1st<_Operation>(__fn, _Arg1_type(__x));
}


template <class _Operation>
class binder2nd
  : public unary_function<typename _Operation::first_argument_type,
                          typename _Operation::result_type> {
protected:
  _Operation op;
  typename _Operation::second_argument_type value;
public:
  binder2nd(const _Operation& __x,
            const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) {}
  typename _Operation::result_type
  operator()(const typename _Operation::first_argument_type& __x) const {
    return op(__x, value);
  }


  typename _Operation::result_type
  operator()(typename _Operation::first_argument_type& __x) const {
    return op(__x, value);
  }

};


template <class _Operation, class _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
  typedef typename _Operation::second_argument_type _Arg2_type;
  return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}
# 438 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 3
template <class _Arg, class _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
protected:
  _Result (*_M_ptr)(_Arg);
public:
  pointer_to_unary_function() {}
  explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
  _Result operator()(_Arg __x) const { return _M_ptr(__x); }
};


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


template <class _Arg1, class _Arg2, class _Result>
class pointer_to_binary_function :
  public binary_function<_Arg1,_Arg2,_Result> {
protected:
    _Result (*_M_ptr)(_Arg1, _Arg2);
public:
    pointer_to_binary_function() {}
    explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) {}
    _Result operator()(_Arg1 __x, _Arg2 __y) const {
      return _M_ptr(__x, __y);
    }
};


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


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

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

template <class _Pair>
struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
{
  typename _Pair::second_type& operator()(_Pair& __x) const {
    return __x.second;
  }
  const typename _Pair::second_type& operator()(const _Pair& __x) const {
    return __x.second;
  }
};
# 528 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_function.h" 3
template <class _Ret, class _Tp>
class mem_fun_t : public unary_function<_Tp*,_Ret> {
public:
  explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)();
};


template <class _Ret, class _Tp>
class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
public:
  explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;
};


template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)();
};


template <class _Ret, class _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;
};


template <class _Ret, class _Tp, class _Arg>
class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
public:
  explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg);
};


template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
public:
  explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p, _Arg __x) const
    { return (__p->*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};


template <class _Ret, class _Tp, class _Arg>
class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg);
};


template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};


template <class _Tp>
class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
public:
  explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  void operator()(_Tp* __p) const { (__p->*_M_f)(); }
private:
  void (_Tp::*_M_f)();
};


template <class _Tp>
class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
public:
  explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
private:
  void (_Tp::*_M_f)() const;
};


template <class _Tp>
class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
  explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  void operator()(_Tp& __r) const { (__r.*_M_f)(); }
private:
  void (_Tp::*_M_f)();
};


template <class _Tp>
class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
  explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
private:
  void (_Tp::*_M_f)() const;
};


template <class _Tp, class _Arg>
class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
public:
  explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg);
};


template <class _Tp, class _Arg>
class const_mem_fun1_t<void, _Tp, _Arg>
  : public binary_function<const _Tp*,_Arg,void> {
public:
  explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg) const;
};


template <class _Tp, class _Arg>
class mem_fun1_ref_t<void, _Tp, _Arg>
  : public binary_function<_Tp,_Arg,void> {
public:
  explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg);
};


template <class _Tp, class _Arg>
class const_mem_fun1_ref_t<void, _Tp, _Arg>
  : public binary_function<_Tp,_Arg,void> {
public:
  explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg) const;
};





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

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

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

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

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

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

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

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



}
# 53 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.h" 3
#define _CPP_BITS_STRING_H 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.h" 3



namespace std
{
# 108 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {

    public:
      typedef _Traits traits_type;
      typedef typename _Traits::char_type value_type;
      typedef _Alloc allocator_type;
      typedef typename _Alloc::size_type size_type;
      typedef typename _Alloc::difference_type difference_type;
      typedef typename _Alloc::reference reference;
      typedef typename _Alloc::const_reference const_reference;
      typedef typename _Alloc::pointer pointer;
      typedef typename _Alloc::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:
# 143 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.h" 3
      struct _Rep
      {

        typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
# 161 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.h" 3
        static const size_type _S_max_size;
        static const _CharT _S_terminal;

        size_type _M_length;
        size_type _M_capacity;
        _Atomic_word _M_references;

        bool
        _M_is_leaked() const
        { return _M_references < 0; }

        bool
        _M_is_shared() const
        { return _M_references > 0; }

        void
        _M_set_leaked()
        { _M_references = -1; }

        void
        _M_set_sharable()
        { _M_references = 0; }

        _CharT*
        _M_refdata() throw()
        { return reinterpret_cast<_CharT*>(this + 1); }

        _CharT&
        operator[](size_t __s) throw()
        { return _M_refdata() [__s]; }

        _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_t, const _Alloc&);

        void
        _M_dispose(const _Alloc& __a)
        {
          if (__exchange_and_add(&_M_references, -1) <= 0)
            _M_destroy(__a);
        }

        void
        _M_destroy(const _Alloc&) throw();

        _CharT*
        _M_refcopy() throw()
        {
          __atomic_add(&_M_references, 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;



      static size_type _S_empty_rep_storage[(sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];

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

      iterator
      _M_check(size_type __pos) const
      {
        if (__pos > this->size())
          __throw_out_of_range("basic_string::_M_check");
        return _M_ibegin() + __pos;
      }


      iterator
      _M_fold(size_type __pos, size_type __off) const
      {
        bool __testoff = __off < this->size() - __pos;
        size_type __newoff = __testoff ? __off : this->size() - __pos;
        return (_M_ibegin() + __pos + __newoff);
      }



      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)
      { traits_type::copy(__p, __k1, __k2 - __k1); }

      static void
      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
      { traits_type::copy(__p, __k1, __k2 - __k1); }

      void
      _M_mutate(size_type __pos, size_type __len1, size_type __len2);

      void
      _M_leak_hard();

      static _Rep&
      _S_empty_rep()
      { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }

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

      basic_string(const _CharT* __s, size_type __n,
                   const _Alloc& __a = _Alloc());
      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());

      template<class _InputIterator>
        basic_string(_InputIterator __beg, _InputIterator __end,
                     const _Alloc& __a = _Alloc());

      ~basic_string()
      { _M_rep()->_M_dispose(this->get_allocator()); }

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

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

      basic_string&
      operator=(_CharT __c) { return this->assign(1, __c); }


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

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

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

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

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

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

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

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

    public:

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

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

      size_type
      max_size() const { return _Rep::_S_max_size; }

      void
      resize(size_type __n, _CharT __c);

      void
      resize(size_type __n) { this->resize(__n, _CharT()); }

      size_type
      capacity() const { return _M_rep()->_M_capacity; }

      void
      reserve(size_type __res_arg = 0);

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

      bool
      empty() const { return this->size() == 0; }


      const_reference
      operator[] (size_type __pos) const
      { return _M_data()[__pos]; }

      reference
      operator[](size_type __pos)
      {
        _M_leak();
        return _M_data()[__pos];
      }

      const_reference
      at(size_type __n) const
      {
        if (__n >= this->size())
          __throw_out_of_range("basic_string::at");
        return _M_data()[__n];
      }

      reference
      at(size_type __n)
      {
        if (__n >= size())
          __throw_out_of_range("basic_string::at");
        _M_leak();
        return _M_data()[__n];
      }


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

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

      basic_string&
      operator+=(_CharT __c) { return this->append(size_type(1), __c); }

      basic_string&
      append(const basic_string& __str);

      basic_string&
      append(const basic_string& __str, size_type __pos, size_type __n);

      basic_string&
      append(const _CharT* __s, size_type __n);

      basic_string&
      append(const _CharT* __s)
      { return this->append(__s, traits_type::length(__s)); }

      basic_string&
      append(size_type __n, _CharT __c);

      template<class _InputIterator>
        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_iend(), _M_iend(), __first, __last); }

      void
      push_back(_CharT __c)
      { this->replace(_M_iend(), _M_iend(), 1, __c); }

      basic_string&
      assign(const basic_string& __str);

      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n);

      basic_string&
      assign(const _CharT* __s, size_type __n);

      basic_string&
      assign(const _CharT* __s)
      { return this->assign(__s, traits_type::length(__s)); }

      basic_string&
      assign(size_type __n, _CharT __c)
      { return this->replace(_M_ibegin(), _M_iend(), __n, __c); }

      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }

      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }

      template<class _InputIterator>
        void insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }

      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      { return this->insert(__pos1, __str, 0, __str.size()); }

      basic_string&
      insert(size_type __pos1, const basic_string& __str,
             size_type __pos2, size_type __n);

      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n);

      basic_string&
      insert(size_type __pos, const _CharT* __s)
      { return this->insert(__pos, __s, traits_type::length(__s)); }

      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      {
        this->insert(_M_check(__pos), __n, __c);
        return *this;
      }

      iterator
      insert(iterator __p, _CharT __c = _CharT())
      {
        size_type __pos = __p - _M_ibegin();
        this->insert(_M_check(__pos), size_type(1), __c);
        _M_rep()->_M_set_leaked();
        return this->_M_ibegin() + __pos;
      }

      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n),
                             _M_data(), _M_data());
      }

      iterator
      erase(iterator __position)
      {
        size_type __i = __position - _M_ibegin();
        this->replace(__position, __position + 1, _M_data(), _M_data());
        _M_rep()->_M_set_leaked();
        return _M_ibegin() + __i;
      }

      iterator
      erase(iterator __first, iterator __last)
      {
        size_type __i = __first - _M_ibegin();
        this->replace(__first, __last, _M_data(), _M_data());
        _M_rep()->_M_set_leaked();
       return _M_ibegin() + __i;
      }

      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }

      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
              size_type __pos2, size_type __n2);

      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
              size_type __n2);

      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      { return this->replace(__pos, __n1, __s, traits_type::length(__s)); }

      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      { return this->replace(_M_check(__pos), _M_fold(__pos, __n1), __n2, __c); }

      basic_string&
      replace(iterator __i1, iterator __i2, const basic_string& __str)
      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }

      basic_string&
      replace(iterator __i1, iterator __i2,
                           const _CharT* __s, size_type __n)
      { return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); }

      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s)
      { return this->replace(__i1, __i2, __s, traits_type::length(__s)); }

      basic_string&
      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c);

      template<class _InputIterator>
        basic_string&
        replace(iterator __i1, iterator __i2,
                _InputIterator __k1, _InputIterator __k2)
        { return _M_replace(__i1, __i2, __k1, __k2,
             typename iterator_traits<_InputIterator>::iterator_category()); }



      basic_string&
      replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
        { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
                               __k1, __k2 - __k1); }

      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __k1, const _CharT* __k2)
        { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
                               __k1, __k2 - __k1); }

      basic_string&
      replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
        { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
                               __k1.base(), __k2 - __k1);
        }

      basic_string&
      replace(iterator __i1, iterator __i2, const_iterator __k1, const_iterator __k2)
        { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
                               __k1.base(), __k2 - __k1);
        }

    private:
      template<class _InputIterator>
        basic_string&
        _M_replace(iterator __i1, iterator __i2, _InputIterator __k1,
                   _InputIterator __k2, input_iterator_tag);

      template<class _ForwardIterator>
        basic_string&
        _M_replace_safe(iterator __i1, iterator __i2, _ForwardIterator __k1,
                   _ForwardIterator __k2);



      template<class _InIter>
        static _CharT*
        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
                         __false_type)
        {
          typedef typename iterator_traits<_InIter>::iterator_category _Tag;
          return _S_construct(__beg, __end, __a, _Tag());
        }

      template<class _InIter>
        static _CharT*
        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
                         __true_type)
        {
          return _S_construct(static_cast<size_type>(__beg),
                              static_cast<value_type>(__end), __a);
        }

      template<class _InIter>
        static _CharT*
        _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a)
        {
          typedef typename _Is_integer<_InIter>::_Integral _Integral;
          return _S_construct_aux(__beg, __end, __a, _Integral());
        }


      template<class _InIter>
        static _CharT*
         _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                      input_iterator_tag);



      template<class _FwdIter>
        static _CharT*
        _S_construct(_FwdIter __beg, _FwdIter __end, const _Alloc& __a,
                     forward_iterator_tag);

      static _CharT*
      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);

    public:

      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;

      void
      swap(basic_string<_CharT, _Traits, _Alloc>& __s);


      const _CharT*
      c_str() const
      {

        size_type __n = this->size();
        traits_type::assign(_M_data()[__n], _Rep::_S_terminal);
        return _M_data();
      }

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

      allocator_type
      get_allocator() const { return _M_dataplus; }

      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      { return this->find(__str.data(), __pos, __str.size()); }

      size_type
      find(const _CharT* __s, size_type __pos = 0) const
      { return this->find(__s, __pos, traits_type::length(__s)); }

      size_type
      find(_CharT __c, size_type __pos = 0) const;

      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      { return this->rfind(__str.data(), __pos, __str.size()); }

      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      { return this->rfind(__s, __pos, traits_type::length(__s)); }

      size_type
      rfind(_CharT __c, size_type __pos = npos) const;

      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_of(__str.data(), __pos, __str.size()); }

      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      { return this->find_first_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }

      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_of(__str.data(), __pos, __str.size()); }

      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      { return this->find_last_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }

      size_type
      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }

      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
                        size_type __n) const;

      size_type
      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
      { return this->find_first_not_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const;

      size_type
      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }

      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
                       size_type __n) const;
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
      { return this->find_last_not_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const;

      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      {
        if (__pos > this->size())
          __throw_out_of_range("basic_string::substr");
        return basic_string(*this, __pos, __n);
      }

      int
      compare(const basic_string& __str) const
      {
        size_type __size = this->size();
        size_type __osize = __str.size();
        size_type __len = std::min(__size, __osize);

        int __r = traits_type::compare(_M_data(), __str.data(), __len);
        if (!__r)
          __r = __size - __osize;
        return __r;
      }

      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;

      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
              size_type __pos2, size_type __n2) const;

      int
      compare(const _CharT* __s) const;



      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;

      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
              size_type __n2) const;
  };


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>::
    basic_string()
    : _M_dataplus(_S_empty_rep()._M_refcopy(), _Alloc()) { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
              const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
             const _CharT* __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str(__lhs);
      __str.append(__size_type(1), __rhs);
      return __str;
    }


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline void
    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
         basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { __lhs.swap(__rhs); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is,
               basic_string<_CharT, _Traits, _Alloc>& __str);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const basic_string<_CharT, _Traits, _Alloc>& __str);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
            basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
            basic_string<_CharT, _Traits, _Alloc>& __str);
}
# 54 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 2 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/algorithm" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/algorithm" 3
#define _CPP_ALGORITHM 1

       
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/algorithm" 3




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
#define __GLIBCPP_INTERNAL_ALGO_H 

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_heap.h" 1 3
# 61 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_heap.h" 3
#define _CPP_BITS_STL_HEAP_H 1

namespace std
{



  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __push_heap(_RandomAccessIterator __first,
                _Distance __holeIndex, _Distance __topIndex, _Tp __value)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
        *(__first + __holeIndex) = *(__first + __parent);
        __holeIndex = __parent;
        __parent = (__holeIndex - 1) / 2;
      }
      *(__first + __holeIndex) = __value;
    }

  template<typename _RandomAccessIterator>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
          _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
          _DistanceType;


     

     

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

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
            typename _Compare>
    void
    __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
                _Distance __topIndex, _Tp __value, _Compare __comp)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
        *(__first + __holeIndex) = *(__first + __parent);
        __holeIndex = __parent;
        __parent = (__holeIndex - 1) / 2;
      }
      *(__first + __holeIndex) = __value;
    }

  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;


     


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

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
                  _Distance __len, _Tp __value)
    {
      _Distance __topIndex = __holeIndex;
      _Distance __secondChild = 2 * __holeIndex + 2;
      while (__secondChild < __len) {
        if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
          __secondChild--;
        *(__first + __holeIndex) = *(__first + __secondChild);
        __holeIndex = __secondChild;
        __secondChild = 2 * (__secondChild + 1);
      }
      if (__secondChild == __len) {
        *(__first + __holeIndex) = *(__first + (__secondChild - 1));
        __holeIndex = __secondChild - 1;
      }
      __push_heap(__first, __holeIndex, __topIndex, __value);
    }

  template<typename _RandomAccessIterator, typename _Tp>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
               _RandomAccessIterator __result, _Tp __value)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
      *__result = *__first;
      __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
    }

  template<typename _RandomAccessIterator>
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;


     

     

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

  template<typename _RandomAccessIterator, typename _Distance,
           typename _Tp, typename _Compare>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
                  _Distance __len, _Tp __value, _Compare __comp)
    {
      _Distance __topIndex = __holeIndex;
      _Distance __secondChild = 2 * __holeIndex + 2;
      while (__secondChild < __len) {
        if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
          __secondChild--;
        *(__first + __holeIndex) = *(__first + __secondChild);
        __holeIndex = __secondChild;
        __secondChild = 2 * (__secondChild + 1);
      }
      if (__secondChild == __len) {
        *(__first + __holeIndex) = *(__first + (__secondChild - 1));
        __holeIndex = __secondChild - 1;
      }
      __push_heap(__first, __holeIndex, __topIndex, __value, __comp);
    }

  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
               _RandomAccessIterator __result, _Tp __value, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
      *__result = *__first;
      __adjust_heap(__first, _Distance(0), _Distance(__last - __first),
                    __value, __comp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    pop_heap(_RandomAccessIterator __first,
             _RandomAccessIterator __last, _Compare __comp)
    {

     


      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
      __pop_heap(__first, __last - 1, __last - 1, _ValueType(*(__last - 1)), __comp);
    }

  template<typename _RandomAccessIterator>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
          _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
          _DistanceType;


     

     

      if (__last - __first < 2) return;
      _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2)/2;

      while (true) {
        __adjust_heap(__first, __parent, __len, _ValueType(*(__first + __parent)));
        if (__parent == 0) return;
        __parent--;
      }
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
              _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
          _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
          _DistanceType;


     


      if (__last - __first < 2) return;
      _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2)/2;

      while (true) {
        __adjust_heap(__first, __parent, __len,
                      _ValueType(*(__first + __parent)), __comp);
        if (__parent == 0) return;
        __parent--;
      }
    }

  template<typename _RandomAccessIterator>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     


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

  template<typename _RandomAccessIterator, typename _Compare>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
              _Compare __comp)
    {

     


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

}
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_tempbuf.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_tempbuf.h" 3
#define __GLIBCPP_INTERNAL_TEMPBUF_H 

namespace std
{
# 74 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_tempbuf.h" 3
template <class _ForwardIterator, class _Tp>
  class _Temporary_buffer
{

 

  ptrdiff_t _M_original_len;
  ptrdiff_t _M_len;
  _Tp* _M_buffer;


  void _M_allocate_buffer() {
    _M_original_len = _M_len;
    _M_buffer = 0;

    if (_M_len > (ptrdiff_t)(2147483647 / sizeof(_Tp)))
      _M_len = 2147483647 / sizeof(_Tp);

    while (_M_len > 0) {
      _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));
      if (_M_buffer)
        break;
      _M_len /= 2;
    }
  }

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

public:

  ptrdiff_t size() const { return _M_len; }

  ptrdiff_t requested_size() const { return _M_original_len; }

  _Tp* begin() { return _M_buffer; }

  _Tp* end() { return _M_buffer + _M_len; }

  _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {

    typedef typename __type_traits<_Tp>::has_trivial_default_constructor
            _Trivial;

    try {
      _M_len = distance(__first, __last);
      _M_allocate_buffer();
      if (_M_len > 0)
        _M_initialize_buffer(*__first, _Trivial());
    }
    catch(...)
      {
        free(_M_buffer);
        _M_buffer = 0;
        _M_len = 0;
        throw;
      }
  }

  ~_Temporary_buffer() {
    _Destroy(_M_buffer, _M_buffer + _M_len);
    free(_M_buffer);
  }

private:

  _Temporary_buffer(const _Temporary_buffer&) {}
  void operator=(const _Temporary_buffer&) {}
};

}
# 66 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 2 3



namespace std
{
# 84 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 118 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 150 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _Function>
    _Function
    for_each(_InputIter __first, _InputIter __last, _Function __f)
    {

     
      for ( ; __first != __last; ++__first)
        __f(*__first);
      return __f;
    }






  template<typename _InputIter, typename _Tp>
    inline _InputIter
    find(_InputIter __first, _InputIter __last,
         const _Tp& __val,
         input_iterator_tag)
    {
      while (__first != __last && !(*__first == __val))
        ++__first;
      return __first;
    }






  template<typename _InputIter, typename _Predicate>
    inline _InputIter
    find_if(_InputIter __first, _InputIter __last,
            _Predicate __pred,
            input_iterator_tag)
    {
      while (__first != __last && !__pred(*__first))
        ++__first;
      return __first;
    }






  template<typename _RandomAccessIter, typename _Tp>
    _RandomAccessIter
    find(_RandomAccessIter __first, _RandomAccessIter __last,
         const _Tp& __val,
         random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIter>::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 _RandomAccessIter, typename _Predicate>
    _RandomAccessIter
    find_if(_RandomAccessIter __first, _RandomAccessIter __last,
            _Predicate __pred,
            random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIter>::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;
      }
    }
# 289 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _Tp>
    inline _InputIter
    find(_InputIter __first, _InputIter __last,
         const _Tp& __val)
    {

     
     

      return find(__first, __last, __val, __iterator_category(__first));
    }
# 309 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _Predicate>
    inline _InputIter
    find_if(_InputIter __first, _InputIter __last,
            _Predicate __pred)
    {

     
     

      return find_if(__first, __last, __pred, __iterator_category(__first));
    }
# 329 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter>
    _ForwardIter
    adjacent_find(_ForwardIter __first, _ForwardIter __last)
    {

     
     

      if (__first == __last)
        return __last;
      _ForwardIter __next = __first;
      while(++__next != __last) {
        if (*__first == *__next)
          return __first;
        __first = __next;
      }
      return __last;
    }
# 358 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _BinaryPredicate>
    _ForwardIter
    adjacent_find(_ForwardIter __first, _ForwardIter __last,
                  _BinaryPredicate __binary_pred)
    {

     
     


      if (__first == __last)
        return __last;
      _ForwardIter __next = __first;
      while(++__next != __last) {
        if (__binary_pred(*__first, *__next))
          return __first;
        __first = __next;
      }
      return __last;
    }
# 387 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _Tp>
    typename iterator_traits<_InputIter>::difference_type
    count(_InputIter __first, _InputIter __last, const _Tp& __value)
    {

     
     

     
      typename iterator_traits<_InputIter>::difference_type __n = 0;
      for ( ; __first != __last; ++__first)
        if (*__first == __value)
          ++__n;
      return __n;
    }
# 411 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _Predicate>
    typename iterator_traits<_InputIter>::difference_type
    count_if(_InputIter __first, _InputIter __last, _Predicate __pred)
    {

     
     

      typename iterator_traits<_InputIter>::difference_type __n = 0;
      for ( ; __first != __last; ++__first)
        if (__pred(*__first))
          ++__n;
      return __n;
    }
# 450 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter1, typename _ForwardIter2>
    _ForwardIter1
    search(_ForwardIter1 __first1, _ForwardIter1 __last1,
           _ForwardIter2 __first2, _ForwardIter2 __last2)
    {

     
     
     




      if (__first1 == __last1 || __first2 == __last2)
        return __first1;


      _ForwardIter2 __tmp(__first2);
      ++__tmp;
      if (__tmp == __last2)
        return find(__first1, __last1, *__first2);



      _ForwardIter2 __p1, __p;

      __p1 = __first2; ++__p1;

      _ForwardIter1 __current = __first1;

      while (__first1 != __last1) {
        __first1 = 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;
    }
# 522 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter1, typename _ForwardIter2, typename _BinaryPred>
    _ForwardIter1
    search(_ForwardIter1 __first1, _ForwardIter1 __last1,
           _ForwardIter2 __first2, _ForwardIter2 __last2,
           _BinaryPred __predicate)
    {

     
     
     




      if (__first1 == __last1 || __first2 == __last2)
        return __first1;


      _ForwardIter2 __tmp(__first2);
      ++__tmp;
      if (__tmp == __last2) {
        while (__first1 != __last1 && !__predicate(*__first1, *__first2))
          ++__first1;
        return __first1;
      }



      _ForwardIter2 __p1, __p;

      __p1 = __first2; ++__p1;

      _ForwardIter1 __current = __first1;

      while (__first1 != __last1) {
        while (__first1 != __last1) {
          if (__predicate(*__first1, *__first2))
            break;
          ++__first1;
        }
        while (__first1 != __last1 && !__predicate(*__first1, *__first2))
          ++__first1;
        if (__first1 == __last1)
          return __last1;

        __p = __p1;
        __current = __first1;
        if (++__current == __last1) return __last1;

        while (__predicate(*__current, *__p)) {
          if (++__p == __last2)
            return __first1;
          if (++__current == __last1)
            return __last1;
        }

        ++__first1;
      }
      return __first1;
    }
# 596 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Integer, typename _Tp>
    _ForwardIter
    search_n(_ForwardIter __first, _ForwardIter __last,
             _Integer __count, const _Tp& __val)
    {

     
     

     

      if (__count <= 0)
        return __first;
      else {
        __first = find(__first, __last, __val);
        while (__first != __last) {
          typename iterator_traits<_ForwardIter>::difference_type __n = __count;
          --__n;
          _ForwardIter __i = __first;
          ++__i;
          while (__i != __last && __n != 0 && *__i == __val) {
            ++__i;
            --__n;
          }
          if (__n == 0)
            return __first;
          else
            __first = find(__i, __last, __val);
        }
        return __last;
      }
    }
# 644 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Integer, typename _Tp,
           typename _BinaryPred>
    _ForwardIter
    search_n(_ForwardIter __first, _ForwardIter __last,
             _Integer __count, const _Tp& __val,
             _BinaryPred __binary_pred)
    {

     
     


      if (__count <= 0)
        return __first;
      else {
        while (__first != __last) {
          if (__binary_pred(*__first, __val))
            break;
          ++__first;
        }
        while (__first != __last) {
          typename iterator_traits<_ForwardIter>::difference_type __n = __count;
          --__n;
          _ForwardIter __i = __first;
          ++__i;
          while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {
            ++__i;
            --__n;
          }
          if (__n == 0)
            return __first;
          else {
            while (__i != __last) {
              if (__binary_pred(*__i, __val))
                break;
              ++__i;
            }
            __first = __i;
          }
        }
        return __last;
      }
    }
# 699 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter1, typename _ForwardIter2>
    _ForwardIter2
    swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
                _ForwardIter2 __first2)
    {

     
     
     


     



      for ( ; __first1 != __last1; ++__first1, ++__first2)
        iter_swap(__first1, __first2);
      return __first2;
    }
# 734 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter, typename _UnaryOperation>
    _OutputIter
    transform(_InputIter __first, _InputIter __last,
              _OutputIter __result, _UnaryOperation __unary_op)
    {

     
     



      for ( ; __first != __last; ++__first, ++__result)
        *__result = __unary_op(*__first);
      return __result;
    }
# 767 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
           typename _BinaryOperation>
    _OutputIter
    transform(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _OutputIter __result,
              _BinaryOperation __binary_op)
    {

     
     
     



      for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
        *__result = __binary_op(*__first1, *__first2);
      return __result;
    }
# 798 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp>
    void
    replace(_ForwardIter __first, _ForwardIter __last,
            const _Tp& __old_value, const _Tp& __new_value)
    {

     
     

     


      for ( ; __first != __last; ++__first)
        if (*__first == __old_value)
          *__first = __new_value;
    }
# 827 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Predicate, typename _Tp>
    void
    replace_if(_ForwardIter __first, _ForwardIter __last,
               _Predicate __pred, const _Tp& __new_value)
    {

     
     

     


      for ( ; __first != __last; ++__first)
        if (__pred(*__first))
          *__first = __new_value;
    }
# 858 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter, typename _Tp>
    _OutputIter
    replace_copy(_InputIter __first, _InputIter __last,
                 _OutputIter __result,
                 const _Tp& __old_value, const _Tp& __new_value)
    {

     
     

     


      for ( ; __first != __last; ++__first, ++__result)
        *__result = *__first == __old_value ? __new_value : *__first;
      return __result;
    }
# 890 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter, typename _Predicate,
           typename _Tp>
    _OutputIter
    replace_copy_if(_InputIter __first, _InputIter __last,
                    _OutputIter __result,
                    _Predicate __pred, const _Tp& __new_value)
    {

     
     

     


      for ( ; __first != __last; ++__first, ++__result)
        *__result = __pred(*__first) ? __new_value : *__first;
      return __result;
    }
# 920 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Generator>
    void
    generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
    {

     
     


      for ( ; __first != __last; ++__first)
        *__first = __gen();
    }
# 944 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _OutputIter, typename _Size, typename _Generator>
    _OutputIter
    generate_n(_OutputIter __first, _Size __n, _Generator __gen)
    {

     



      for ( ; __n > 0; --__n, ++__first)
        *__first = __gen();
      return __first;
    }
# 971 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter, typename _Tp>
    _OutputIter
    remove_copy(_InputIter __first, _InputIter __last,
                _OutputIter __result, const _Tp& __value)
    {

     
     

     


      for ( ; __first != __last; ++__first)
        if (!(*__first == __value)) {
          *__result = *__first;
          ++__result;
        }
      return __result;
    }
# 1005 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter, typename _Predicate>
    _OutputIter
    remove_copy_if(_InputIter __first, _InputIter __last,
                   _OutputIter __result, _Predicate __pred)
    {

     
     

     


      for ( ; __first != __last; ++__first)
        if (!__pred(*__first)) {
          *__result = *__first;
          ++__result;
        }
      return __result;
    }
# 1041 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp>
    _ForwardIter
    remove(_ForwardIter __first, _ForwardIter __last,
           const _Tp& __value)
    {

     
     

     


      __first = find(__first, __last, __value);
      _ForwardIter __i = __first;
      return __first == __last ? __first
                               : remove_copy(++__i, __last, __first, __value);
    }
# 1075 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Predicate>
    _ForwardIter
    remove_if(_ForwardIter __first, _ForwardIter __last,
              _Predicate __pred)
    {

     
     


      __first = find_if(__first, __last, __pred);
      _ForwardIter __i = __first;
      return __first == __last ? __first
                               : remove_copy_if(++__i, __last, __first, __pred);
    }







  template<typename _InputIter, typename _OutputIter>
    _OutputIter
    __unique_copy(_InputIter __first, _InputIter __last,
                  _OutputIter __result,
                  output_iterator_tag)
    {

      typename iterator_traits<_InputIter>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
        if (!(__value == *__first)) {
          __value = *__first;
          *++__result = __value;
        }
      return ++__result;
    }







  template<typename _InputIter, typename _ForwardIter>
    _ForwardIter
    __unique_copy(_InputIter __first, _InputIter __last,
                  _ForwardIter __result,
                  forward_iterator_tag)
    {

      *__result = *__first;
      while (++__first != __last)
        if (!(*__result == *__first))
          *++__result = *__first;
      return ++__result;
    }
# 1147 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter>
    inline _OutputIter
    unique_copy(_InputIter __first, _InputIter __last,
                _OutputIter __result)
    {

     
     

     


      typedef typename iterator_traits<_OutputIter>::iterator_category _IterType;

      if (__first == __last) return __result;
      return __unique_copy(__first, __last, __result, _IterType());
    }
# 1172 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
    _OutputIter
    __unique_copy(_InputIter __first, _InputIter __last,
                  _OutputIter __result,
                  _BinaryPredicate __binary_pred,
                  output_iterator_tag)
    {

     



      typename iterator_traits<_InputIter>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
        if (!__binary_pred(__value, *__first)) {
          __value = *__first;
          *++__result = __value;
        }
      return ++__result;
    }
# 1201 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _ForwardIter, typename _BinaryPredicate>
    _ForwardIter
    __unique_copy(_InputIter __first, _InputIter __last,
                  _ForwardIter __result,
                  _BinaryPredicate __binary_pred,
                  forward_iterator_tag)
    {

     



      *__result = *__first;
      while (++__first != __last)
        if (!__binary_pred(*__result, *__first)) *++__result = *__first;
      return ++__result;
    }
# 1234 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
    inline _OutputIter
    unique_copy(_InputIter __first, _InputIter __last,
                _OutputIter __result,
                _BinaryPredicate __binary_pred)
    {

     
     


      typedef typename iterator_traits<_OutputIter>::iterator_category _IterType;

      if (__first == __last) return __result;
      return __unique_copy(__first, __last,
__result, __binary_pred, _IterType());
    }
# 1265 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter>
    _ForwardIter
    unique(_ForwardIter __first, _ForwardIter __last)
    {

         
         


          __first = adjacent_find(__first, __last);
          return unique_copy(__first, __last, __first);
    }
# 1292 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _BinaryPredicate>
    _ForwardIter
    unique(_ForwardIter __first, _ForwardIter __last,
           _BinaryPredicate __binary_pred)
    {

     
     



      __first = adjacent_find(__first, __last, __binary_pred);
      return unique_copy(__first, __last, __first, __binary_pred);
    }







  template<typename _BidirectionalIter>
    void
    __reverse(_BidirectionalIter __first, _BidirectionalIter __last,
                          bidirectional_iterator_tag)
    {
          while (true)
            if (__first == __last || __first == --__last)
                  return;
            else
                  iter_swap(__first++, __last);
    }







  template<typename _RandomAccessIter>
    void
    __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
                          random_access_iterator_tag)
    {
          while (__first < __last)
            iter_swap(__first++, --__last);
    }
# 1351 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _BidirectionalIter>
    inline void
    reverse(_BidirectionalIter __first, _BidirectionalIter __last)
    {

         

          __reverse(__first, __last, __iterator_category(__first));
    }
# 1376 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _BidirectionalIter, typename _OutputIter>
    _OutputIter
    reverse_copy(_BidirectionalIter __first, _BidirectionalIter __last,
                             _OutputIter __result)
    {

     
     


      while (__first != __last) {
        --__last;
        *__result = *__last;
        ++__result;
      }
      return __result;
    }
# 1401 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _EuclideanRingElement>
    _EuclideanRingElement
    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    {
      while (__n != 0) {
        _EuclideanRingElement __t = __m % __n;
        __m = __n;
        __n = __t;
      }
      return __m;
    }






  template<typename _ForwardIter>
    void
    __rotate(_ForwardIter __first,
             _ForwardIter __middle,
             _ForwardIter __last,
              forward_iterator_tag)
    {
      if ((__first == __middle) || (__last == __middle))
        return;

      _ForwardIter __first2 = __middle;
      do {
        swap(*__first++, *__first2++);
        if (__first == __middle)
          __middle = __first2;
      } while (__first2 != __last);

      __first2 = __middle;

      while (__first2 != __last) {
        swap(*__first++, *__first2++);
        if (__first == __middle)
          __middle = __first2;
        else if (__first2 == __last)
          __first2 = __middle;
      }
    }






  template<typename _BidirectionalIter>
    void
    __rotate(_BidirectionalIter __first,
             _BidirectionalIter __middle,
             _BidirectionalIter __last,
              bidirectional_iterator_tag)
    {

     


      if ((__first == __middle) || (__last == __middle))
        return;

      __reverse(__first, __middle, bidirectional_iterator_tag());
      __reverse(__middle, __last, bidirectional_iterator_tag());

      while (__first != __middle && __middle != __last)
        swap (*__first++, *--__last);

      if (__first == __middle) {
        __reverse(__middle, __last, bidirectional_iterator_tag());
      }
      else {
        __reverse(__first, __middle, bidirectional_iterator_tag());
      }
    }






  template<typename _RandomAccessIter>
    void
    __rotate(_RandomAccessIter __first,
             _RandomAccessIter __middle,
             _RandomAccessIter __last,
             random_access_iterator_tag)
    {

     


      if ((__first == __middle) || (__last == __middle))
        return;

      typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;

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

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

      _Distance __d = __gcd(__n, __k);

      for (_Distance __i = 0; __i < __d; __i++) {
        _ValueType __tmp = *__first;
        _RandomAccessIter __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;
      }
    }
# 1563 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter>
    inline void
    rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last)
    {

     

      typedef typename iterator_traits<_ForwardIter>::iterator_category _IterType;
      __rotate(__first, __middle, __last, _IterType());
    }
# 1591 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _OutputIter>
    _OutputIter
    rotate_copy(_ForwardIter __first, _ForwardIter __middle,
                _ForwardIter __last, _OutputIter __result)
    {

     
     


      return copy(__first, __middle, copy(__middle, __last, __result));
    }
# 1614 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _Distance>
    inline _Distance
    __random_number(_Distance __n)
    {

      return lrand48() % __n;



    }
# 1636 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter>
    inline void
    random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last)
    {

     


      if (__first == __last) return;
      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
        iter_swap(__i, __first + __random_number((__i - __first) + 1));
    }
# 1662 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter, typename _RandomNumberGenerator>
    void
    random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
                   _RandomNumberGenerator& __rand)
    {

     


      if (__first == __last) return;
      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
        iter_swap(__i, __first + __rand((__i - __first) + 1));
    }







  template<typename _ForwardIter, typename _Predicate>
    _ForwardIter
    __partition(_ForwardIter __first, _ForwardIter __last,
                _Predicate __pred,
                forward_iterator_tag)
    {
      if (__first == __last) return __first;

      while (__pred(*__first))
        if (++__first == __last) return __first;

      _ForwardIter __next = __first;

      while (++__next != __last)
        if (__pred(*__next)) {
          swap(*__first, *__next);
          ++__first;
        }

      return __first;
    }






  template<typename _BidirectionalIter, typename _Predicate>
    _BidirectionalIter
    __partition(_BidirectionalIter __first, _BidirectionalIter __last,
                _Predicate __pred,
                bidirectional_iterator_tag)
    {
      while (true) {
        while (true)
          if (__first == __last)
            return __first;
          else if (__pred(*__first))
            ++__first;
          else
            break;
        --__last;
        while (true)
          if (__first == __last)
            return __first;
          else if (!__pred(*__last))
            --__last;
          else
            break;
        iter_swap(__first, __last);
        ++__first;
      }
    }
# 1750 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Predicate>
    inline _ForwardIter
    partition(_ForwardIter __first, _ForwardIter __last,
              _Predicate __pred)
    {

     
     


      return __partition(__first, __last, __pred, __iterator_category(__first));
    }







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






  template<typename _ForwardIter, typename _Pointer, typename _Predicate,
           typename _Distance>
    _ForwardIter
    __stable_partition_adaptive(_ForwardIter __first, _ForwardIter __last,
                                _Predicate __pred, _Distance __len,
                                _Pointer __buffer,
                                _Distance __buffer_size)
    {
      if (__len <= __buffer_size) {
        _ForwardIter __result1 = __first;
        _Pointer __result2 = __buffer;
        for ( ; __first != __last ; ++__first)
          if (__pred(*__first)) {
            *__result1 = *__first;
            ++__result1;
          }
          else {
            *__result2 = *__first;
            ++__result2;
          }
        copy(__buffer, __result2, __result1);
        return __result1;
      }
      else {
        _ForwardIter __middle = __first;
        advance(__middle, __len / 2);
        _ForwardIter __begin = __stable_partition_adaptive(__first, __middle,
                                                           __pred,
                                                           __len / 2,
                                                           __buffer, __buffer_size);
        _ForwardIter __end = __stable_partition_adaptive( __middle, __last,
                                                          __pred,
                                                          __len - __len / 2,
                                                          __buffer, __buffer_size);
        rotate(__begin, __middle, __end);
        advance(__begin, distance(__middle, __end));
        return __begin;
      }
    }
# 1850 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Predicate>
    _ForwardIter
    stable_partition(_ForwardIter __first, _ForwardIter __last,
                     _Predicate __pred)
    {

     
     


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

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






  template<typename _RandomAccessIter, typename _Tp>
    _RandomAccessIter
    __unguarded_partition(_RandomAccessIter __first, _RandomAccessIter __last,
                          _Tp __pivot)
    {
      while (true) {
        while (*__first < __pivot)
          ++__first;
        --__last;
        while (__pivot < *__last)
          --__last;
        if (!(__first < __last))
          return __first;
        iter_swap(__first, __last);
        ++__first;
      }
    }






  template<typename _RandomAccessIter, typename _Tp, typename _Compare>
    _RandomAccessIter
    __unguarded_partition(_RandomAccessIter __first, _RandomAccessIter __last,
                          _Tp __pivot, _Compare __comp)
    {
      while (true) {
        while (__comp(*__first, __pivot))
          ++__first;
        --__last;
        while (__comp(__pivot, *__last))
          --__last;
        if (!(__first < __last))
          return __first;
        iter_swap(__first, __last);
        ++__first;
      }
    }
# 1931 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  enum { _M_threshold = 16 };






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






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






  template<typename _RandomAccessIter>
    void
    __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
    {
      if (__first == __last) return;

      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
      {
        typename iterator_traits<_RandomAccessIter>::value_type __val = *__i;
        if (__val < *__first) {
          copy_backward(__first, __i, __i + 1);
          *__first = __val;
        }
        else
          __unguarded_linear_insert(__i, __val);
      }
    }






  template<typename _RandomAccessIter, typename _Compare>
    void
    __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
                     _Compare __comp)
    {
      if (__first == __last) return;

      for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
      {
        typename iterator_traits<_RandomAccessIter>::value_type __val = *__i;
        if (__comp(__val, *__first)) {
          copy_backward(__first, __i, __i + 1);
          *__first = __val;
        }
        else
          __unguarded_linear_insert(__i, __val, __comp);
      }
    }






  template<typename _RandomAccessIter>
    inline void
    __unguarded_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;

      for (_RandomAccessIter __i = __first; __i != __last; ++__i)
        __unguarded_linear_insert(__i, _ValueType(*__i));
    }






  template<typename _RandomAccessIter, typename _Compare>
    inline void
    __unguarded_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
                               _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;

      for (_RandomAccessIter __i = __first; __i != __last; ++__i)
        __unguarded_linear_insert(__i, _ValueType(*__i), __comp);
    }






  template<typename _RandomAccessIter>
    void
    __final_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
    {
      if (__last - __first > _M_threshold) {
        __insertion_sort(__first, __first + _M_threshold);
        __unguarded_insertion_sort(__first + _M_threshold, __last);
      }
      else
        __insertion_sort(__first, __last);
    }






  template<typename _RandomAccessIter, typename _Compare>
    void
    __final_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
                           _Compare __comp)
    {
      if (__last - __first > _M_threshold) {
        __insertion_sort(__first, __first + _M_threshold, __comp);
        __unguarded_insertion_sort(__first + _M_threshold, __last, __comp);
      }
      else
        __insertion_sort(__first, __last, __comp);
    }






  template<typename _Size>
    inline _Size
    __lg(_Size __n)
    {
      _Size __k;
      for (__k = 0; __n != 1; __n >>= 1) ++__k;
      return __k;
    }






  template<typename _RandomAccessIter, typename _Size>
    void
    __introsort_loop(_RandomAccessIter __first, _RandomAccessIter __last,
                     _Size __depth_limit)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;

      while (__last - __first > _M_threshold) {
        if (__depth_limit == 0) {
          partial_sort(__first, __last, __last);
          return;
        }
        --__depth_limit;
        _RandomAccessIter __cut =
          __unguarded_partition(__first, __last,
                                _ValueType(__median(*__first,
                                                    *(__first + (__last - __first)/2),
                                                    *(__last - 1))));
        __introsort_loop(__cut, __last, __depth_limit);
        __last = __cut;
      }
    }






  template<typename _RandomAccessIter, typename _Size, typename _Compare>
    void
    __introsort_loop(_RandomAccessIter __first, _RandomAccessIter __last,
                     _Size __depth_limit, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;

      while (__last - __first > _M_threshold) {
        if (__depth_limit == 0) {
          partial_sort(__first, __last, __last, __comp);
          return;
        }
        --__depth_limit;
        _RandomAccessIter __cut =
          __unguarded_partition(__first, __last,
                                _ValueType(__median(*__first,
                                                    *(__first + (__last - __first)/2),
                                                    *(__last - 1), __comp)),
           __comp);
        __introsort_loop(__cut, __last, __depth_limit, __comp);
        __last = __cut;
      }
    }
# 2168 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter>
    inline void
    sort(_RandomAccessIter __first, _RandomAccessIter __last)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;


     

     

      if (__first != __last) {
        __introsort_loop(__first, __last, __lg(__last - __first) * 2);
        __final_insertion_sort(__first, __last);
      }
    }
# 2199 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter, typename _Compare>
    inline void
    sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;


     

     

      if (__first != __last) {
        __introsort_loop(__first, __last, __lg(__last - __first) * 2, __comp);
        __final_insertion_sort(__first, __last, __comp);
      }
    }







  template<typename _RandomAccessIter>
    void
    __inplace_stable_sort(_RandomAccessIter __first, _RandomAccessIter __last)
    {
      if (__last - __first < 15) {
        __insertion_sort(__first, __last);
        return;
      }
      _RandomAccessIter __middle = __first + (__last - __first) / 2;
      __inplace_stable_sort(__first, __middle);
      __inplace_stable_sort(__middle, __last);
      __merge_without_buffer(__first, __middle, __last,
                             __middle - __first,
                             __last - __middle);
    }






  template<typename _RandomAccessIter, typename _Compare>
    void
    __inplace_stable_sort(_RandomAccessIter __first, _RandomAccessIter __last,
                          _Compare __comp)
    {
      if (__last - __first < 15) {
        __insertion_sort(__first, __last, __comp);
        return;
      }
      _RandomAccessIter __middle = __first + (__last - __first) / 2;
      __inplace_stable_sort(__first, __middle, __comp);
      __inplace_stable_sort(__middle, __last, __comp);
      __merge_without_buffer(__first, __middle, __last,
                             __middle - __first,
                             __last - __middle,
                             __comp);
    }

  template<typename _RandomAccessIter1, typename _RandomAccessIter2,
           typename _Distance>
    void
    __merge_sort_loop(_RandomAccessIter1 __first, _RandomAccessIter1 __last,
                      _RandomAccessIter2 __result, _Distance __step_size)
    {
      _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step) {
        __result = merge(__first, __first + __step_size,
                         __first + __step_size, __first + __two_step,
                         __result);
        __first += __two_step;
      }

      __step_size = min(_Distance(__last - __first), __step_size);
      merge(__first, __first + __step_size, __first + __step_size, __last,
            __result);
    }

  template<typename _RandomAccessIter1, typename _RandomAccessIter2,
           typename _Distance, typename _Compare>
    void
    __merge_sort_loop(_RandomAccessIter1 __first, _RandomAccessIter1 __last,
                      _RandomAccessIter2 __result, _Distance __step_size,
                      _Compare __comp)
    {
      _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step) {
        __result = merge(__first, __first + __step_size,
                         __first + __step_size, __first + __two_step,
                         __result,
                         __comp);
        __first += __two_step;
      }
      __step_size = min(_Distance(__last - __first), __step_size);

      merge(__first, __first + __step_size,
            __first + __step_size, __last,
            __result,
            __comp);
    }

  enum { _M_chunk_size = 7 };

  template<typename _RandomAccessIter, typename _Distance>
    void
    __chunk_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
                           _Distance __chunk_size)
    {
      while (__last - __first >= __chunk_size) {
        __insertion_sort(__first, __first + __chunk_size);
        __first += __chunk_size;
      }
      __insertion_sort(__first, __last);
    }

  template<typename _RandomAccessIter, typename _Distance, typename _Compare>
    void
    __chunk_insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last,
                           _Distance __chunk_size, _Compare __comp)
    {
      while (__last - __first >= __chunk_size) {
        __insertion_sort(__first, __first + __chunk_size, __comp);
        __first += __chunk_size;
      }
      __insertion_sort(__first, __last, __comp);
    }

  template<typename _RandomAccessIter, typename _Pointer>
    void
    __merge_sort_with_buffer(_RandomAccessIter __first, _RandomAccessIter __last,
                             _Pointer __buffer)
    {
      typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;

      _Distance __len = __last - __first;
      _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _M_chunk_size;
      __chunk_insertion_sort(__first, __last, __step_size);

      while (__step_size < __len) {
        __merge_sort_loop(__first, __last, __buffer, __step_size);
        __step_size *= 2;
        __merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
        __step_size *= 2;
      }
    }

  template<typename _RandomAccessIter, typename _Pointer, typename _Compare>
    void
    __merge_sort_with_buffer(_RandomAccessIter __first, _RandomAccessIter __last,
                             _Pointer __buffer, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIter>::difference_type _Distance;

      _Distance __len = __last - __first;
      _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _M_chunk_size;
      __chunk_insertion_sort(__first, __last, __step_size, __comp);

      while (__step_size < __len) {
        __merge_sort_loop(__first, __last, __buffer, __step_size, __comp);
        __step_size *= 2;
        __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
        __step_size *= 2;
      }
    }

  template<typename _RandomAccessIter, typename _Pointer, typename _Distance>
    void
    __stable_sort_adaptive(_RandomAccessIter __first, _RandomAccessIter __last,
                           _Pointer __buffer, _Distance __buffer_size)
    {
      _Distance __len = (__last - __first + 1) / 2;
      _RandomAccessIter __middle = __first + __len;
      if (__len > __buffer_size) {
        __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
        __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
      }
      else {
        __merge_sort_with_buffer(__first, __middle, __buffer);
        __merge_sort_with_buffer(__middle, __last, __buffer);
      }
      __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
                       _Distance(__last - __middle), __buffer, __buffer_size);
    }

  template<typename _RandomAccessIter, typename _Pointer, typename _Distance,
           typename _Compare>
    void
    __stable_sort_adaptive(_RandomAccessIter __first, _RandomAccessIter __last,
                           _Pointer __buffer, _Distance __buffer_size,
                           _Compare __comp)
    {
      _Distance __len = (__last - __first + 1) / 2;
      _RandomAccessIter __middle = __first + __len;
      if (__len > __buffer_size) {
        __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size,
                               __comp);
        __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size,
                               __comp);
      }
      else {
        __merge_sort_with_buffer(__first, __middle, __buffer, __comp);
        __merge_sort_with_buffer(__middle, __last, __buffer, __comp);
      }
      __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
                       _Distance(__last - __middle), __buffer, __buffer_size,
                       __comp);
    }
# 2432 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter>
    inline void
    stable_sort(_RandomAccessIter __first, _RandomAccessIter __last)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;


     

     

      _Temporary_buffer<_RandomAccessIter, _ValueType> buf(__first, __last);
      if (buf.begin() == 0)
        __inplace_stable_sort(__first, __last);
      else
        __stable_sort_adaptive(__first, __last, buf.begin(), _DistanceType(buf.size()));
    }
# 2468 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter, typename _Compare>
    inline void
    stable_sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;
      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;


     

     


      _Temporary_buffer<_RandomAccessIter, _ValueType> buf(__first, __last);
      if (buf.begin() == 0)
        __inplace_stable_sort(__first, __last, __comp);
      else
        __stable_sort_adaptive(__first, __last, buf.begin(), _DistanceType(buf.size()),
                               __comp);
    }
# 2504 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter>
    void
    partial_sort(_RandomAccessIter __first,
                 _RandomAccessIter __middle,
                 _RandomAccessIter __last)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;


     

     

      make_heap(__first, __middle);
      for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
        if (*__i < *__first)
          __pop_heap(__first, __middle, __i, _ValueType(*__i));
      sort_heap(__first, __middle);
    }
# 2542 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter, typename _Compare>
    void
    partial_sort(_RandomAccessIter __first,
                 _RandomAccessIter __middle,
                 _RandomAccessIter __last,
                 _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;


     

     


      make_heap(__first, __middle, __comp);
      for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
        if (__comp(*__i, *__first))
          __pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
      sort_heap(__first, __middle, __comp);
    }
# 2581 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _RandomAccessIter>
    _RandomAccessIter
    partial_sort_copy(_InputIter __first, _InputIter __last,
                      _RandomAccessIter __result_first,
                      _RandomAccessIter __result_last)
    {
      typedef typename iterator_traits<_InputIter>::value_type _InputValueType;
      typedef typename iterator_traits<_RandomAccessIter>::value_type _OutputValueType;
      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;


     
     
     
     

      if (__result_first == __result_last) return __result_last;
      _RandomAccessIter __result_real_last = __result_first;
      while(__first != __last && __result_real_last != __result_last) {
        *__result_real_last = *__first;
        ++__result_real_last;
        ++__first;
      }
      make_heap(__result_first, __result_real_last);
      while (__first != __last) {
        if (*__first < *__result_first)
          __adjust_heap(__result_first, _DistanceType(0),
                        _DistanceType(__result_real_last - __result_first),
                        _InputValueType(*__first));
        ++__first;
      }
      sort_heap(__result_first, __result_real_last);
      return __result_real_last;
    }
# 2635 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter, typename _RandomAccessIter, typename _Compare>
    _RandomAccessIter
    partial_sort_copy(_InputIter __first, _InputIter __last,
                      _RandomAccessIter __result_first,
                      _RandomAccessIter __result_last,
                      _Compare __comp)
    {
      typedef typename iterator_traits<_InputIter>::value_type _InputValueType;
      typedef typename iterator_traits<_RandomAccessIter>::value_type _OutputValueType;
      typedef typename iterator_traits<_RandomAccessIter>::difference_type _DistanceType;


     
     
     
     


      if (__result_first == __result_last) return __result_last;
      _RandomAccessIter __result_real_last = __result_first;
      while(__first != __last && __result_real_last != __result_last) {
        *__result_real_last = *__first;
        ++__result_real_last;
        ++__first;
      }
      make_heap(__result_first, __result_real_last, __comp);
      while (__first != __last) {
        if (__comp(*__first, *__result_first))
          __adjust_heap(__result_first, _DistanceType(0),
                        _DistanceType(__result_real_last - __result_first),
                        _InputValueType(*__first),
                        __comp);
        ++__first;
      }
      sort_heap(__result_first, __result_real_last, __comp);
      return __result_real_last;
    }
# 2688 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter>
    void
    nth_element(_RandomAccessIter __first,
                _RandomAccessIter __nth,
                _RandomAccessIter __last)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;


     
     

      while (__last - __first > 3) {
        _RandomAccessIter __cut =
          __unguarded_partition(__first, __last,
                                _ValueType(__median(*__first,
                                                    *(__first + (__last - __first)/2),
                                                    *(__last - 1))));
        if (__cut <= __nth)
          __first = __cut;
        else
          __last = __cut;
      }
      __insertion_sort(__first, __last);
    }
# 2730 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter, typename _Compare>
    void
    nth_element(_RandomAccessIter __first,
                _RandomAccessIter __nth,
                _RandomAccessIter __last,
                            _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIter>::value_type _ValueType;


     
     


      while (__last - __first > 3) {
        _RandomAccessIter __cut =
          __unguarded_partition(__first, __last,
                                _ValueType(__median(*__first,
                                                    *(__first + (__last - __first)/2),
                                                    *(__last - 1),
                                                    __comp)),
                                __comp);
        if (__cut <= __nth)
          __first = __cut;
        else
          __last = __cut;
      }
      __insertion_sort(__first, __last, __comp);
    }
# 2770 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp>
    _ForwardIter
    lower_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;






     
     
     

      _DistanceType __len = distance(__first, __last);
      _DistanceType __half;
      _ForwardIter __middle;

      while (__len > 0) {
        __half = __len >> 1;
        __middle = __first;
        advance(__middle, __half);
        if (*__middle < __val) {
          __first = __middle;
          ++__first;
          __len = __len - __half - 1;
        }
        else
          __len = __half;
      }
      return __first;
    }
# 2818 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp, typename _Compare>
    _ForwardIter
    lower_bound(_ForwardIter __first, _ForwardIter __last,
                const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;


     
     

      _DistanceType __len = distance(__first, __last);
      _DistanceType __half;
      _ForwardIter __middle;

      while (__len > 0) {
        __half = __len >> 1;
        __middle = __first;
        advance(__middle, __half);
        if (__comp(*__middle, __val)) {
          __first = __middle;
          ++__first;
          __len = __len - __half - 1;
        }
        else
          __len = __half;
      }
      return __first;
    }
# 2858 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp>
    _ForwardIter
    upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;



     
     
     

      _DistanceType __len = distance(__first, __last);
      _DistanceType __half;
      _ForwardIter __middle;

      while (__len > 0) {
        __half = __len >> 1;
        __middle = __first;
        advance(__middle, __half);
        if (__val < *__middle)
          __len = __half;
        else {
          __first = __middle;
          ++__first;
          __len = __len - __half - 1;
        }
      }
      return __first;
    }
# 2903 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp, typename _Compare>
    _ForwardIter
    upper_bound(_ForwardIter __first, _ForwardIter __last,
                const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;


     
     

      _DistanceType __len = distance(__first, __last);
      _DistanceType __half;
      _ForwardIter __middle;

      while (__len > 0) {
        __half = __len >> 1;
        __middle = __first;
        advance(__middle, __half);
        if (__comp(__val, *__middle))
          __len = __half;
        else {
          __first = __middle;
          ++__first;
          __len = __len - __half - 1;
        }
      }
      return __first;
    }
# 2950 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp>
    pair<_ForwardIter, _ForwardIter>
    equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;



     
     
     

      _DistanceType __len = distance(__first, __last);
      _DistanceType __half;
      _ForwardIter __middle, __left, __right;

      while (__len > 0) {
        __half = __len >> 1;
        __middle = __first;
        advance(__middle, __half);
        if (*__middle < __val) {
          __first = __middle;
          ++__first;
          __len = __len - __half - 1;
        }
        else if (__val < *__middle)
          __len = __half;
        else {
          __left = lower_bound(__first, __middle, __val);
          advance(__first, __len);
          __right = upper_bound(++__middle, __first, __val);
          return pair<_ForwardIter, _ForwardIter>(__left, __right);
        }
      }
      return pair<_ForwardIter, _ForwardIter>(__first, __first);
    }
# 3005 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp, typename _Compare>
    pair<_ForwardIter, _ForwardIter>
    equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
                _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
      typedef typename iterator_traits<_ForwardIter>::difference_type _DistanceType;


     
     
     

      _DistanceType __len = distance(__first, __last);
      _DistanceType __half;
      _ForwardIter __middle, __left, __right;

      while (__len > 0) {
        __half = __len >> 1;
        __middle = __first;
        advance(__middle, __half);
        if (__comp(*__middle, __val)) {
          __first = __middle;
          ++__first;
          __len = __len - __half - 1;
        }
        else if (__comp(__val, *__middle))
          __len = __half;
        else {
          __left = lower_bound(__first, __middle, __val, __comp);
          advance(__first, __len);
          __right = upper_bound(++__middle, __first, __val, __comp);
          return pair<_ForwardIter, _ForwardIter>(__left, __right);
        }
      }
      return pair<_ForwardIter, _ForwardIter>(__first, __first);
    }
# 3054 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp>
    bool
    binary_search(_ForwardIter __first, _ForwardIter __last,
                  const _Tp& __val)
    {


     
     

     

      _ForwardIter __i = lower_bound(__first, __last, __val);
      return __i != __last && !(__val < *__i);
    }
# 3085 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter, typename _Tp, typename _Compare>
    bool
    binary_search(_ForwardIter __first, _ForwardIter __last,
                  const _Tp& __val, _Compare __comp)
    {

     
     

     


      _ForwardIter __i = lower_bound(__first, __last, __val, __comp);
      return __i != __last && !__comp(__val, *__i);
    }
# 3117 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
    _OutputIter
    merge(_InputIter1 __first1, _InputIter1 __last1,
          _InputIter2 __first2, _InputIter2 __last2,
          _OutputIter __result)
    {

     
     
     

     


     


      while (__first1 != __last1 && __first2 != __last2) {
        if (*__first2 < *__first1) {
          *__result = *__first2;
          ++__first2;
        }
        else {
          *__result = *__first1;
          ++__first1;
        }
        ++__result;
      }
      return copy(__first2, __last2, copy(__first1, __last1, __result));
    }
# 3168 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
           typename _Compare>
    _OutputIter
    merge(_InputIter1 __first1, _InputIter1 __last1,
          _InputIter2 __first2, _InputIter2 __last2,
          _OutputIter __result, _Compare __comp)
    {

     
     
     


     

     



      while (__first1 != __last1 && __first2 != __last2) {
        if (__comp(*__first2, *__first1)) {
          *__result = *__first2;
          ++__first2;
        }
        else {
          *__result = *__first1;
          ++__first1;
        }
        ++__result;
      }
      return copy(__first2, __last2, copy(__first1, __last1, __result));
    }






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






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






  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
           typename _Distance>
    _BidirectionalIter1
    __rotate_adaptive(_BidirectionalIter1 __first,
                      _BidirectionalIter1 __middle,
                      _BidirectionalIter1 __last,
                      _Distance __len1, _Distance __len2,
                      _BidirectionalIter2 __buffer,
                      _Distance __buffer_size)
    {
      _BidirectionalIter2 __buffer_end;
      if (__len1 > __len2 && __len2 <= __buffer_size) {
        __buffer_end = copy(__middle, __last, __buffer);
        copy_backward(__first, __middle, __last);
        return copy(__buffer, __buffer_end, __first);
      }
      else if (__len1 <= __buffer_size) {
        __buffer_end = copy(__first, __middle, __buffer);
        copy(__middle, __last, __first);
        return copy_backward(__buffer, __buffer_end, __last);
      }
      else {
        rotate(__first, __middle, __last);
        advance(__first, distance(__middle, __last));
        return __first;
      }
    }






  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
           typename _BidirectionalIter3>
    _BidirectionalIter3
    __merge_backward(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
                     _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
                     _BidirectionalIter3 __result)
    {
      if (__first1 == __last1)
        return copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
        return copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true) {
        if (*__last2 < *__last1) {
          *--__result = *__last1;
          if (__first1 == __last1)
            return copy_backward(__first2, ++__last2, __result);
          --__last1;
        }
        else {
          *--__result = *__last2;
          if (__first2 == __last2)
            return copy_backward(__first1, ++__last1, __result);
          --__last2;
        }
      }
    }






  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
           typename _BidirectionalIter3, typename _Compare>
    _BidirectionalIter3
    __merge_backward(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
                     _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
                     _BidirectionalIter3 __result,
                     _Compare __comp)
    {
      if (__first1 == __last1)
        return copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
        return copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true) {
        if (__comp(*__last2, *__last1)) {
          *--__result = *__last1;
          if (__first1 == __last1)
            return copy_backward(__first2, ++__last2, __result);
          --__last1;
        }
        else {
          *--__result = *__last2;
          if (__first2 == __last2)
            return copy_backward(__first1, ++__last1, __result);
          --__last2;
        }
      }
    }






  template<typename _BidirectionalIter, typename _Distance, typename _Pointer>
    void
    __merge_adaptive(_BidirectionalIter __first,
                     _BidirectionalIter __middle,
                     _BidirectionalIter __last,
                     _Distance __len1, _Distance __len2,
                     _Pointer __buffer, _Distance __buffer_size)
    {
          if (__len1 <= __len2 && __len1 <= __buffer_size) {
            _Pointer __buffer_end = copy(__first, __middle, __buffer);
            merge(__buffer, __buffer_end, __middle, __last, __first);
          }
          else if (__len2 <= __buffer_size) {
            _Pointer __buffer_end = copy(__middle, __last, __buffer);
            __merge_backward(__first, __middle, __buffer, __buffer_end, __last);
          }
          else {
            _BidirectionalIter __first_cut = __first;
            _BidirectionalIter __second_cut = __middle;
            _Distance __len11 = 0;
            _Distance __len22 = 0;
            if (__len1 > __len2) {
                  __len11 = __len1 / 2;
                  advance(__first_cut, __len11);
                  __second_cut = lower_bound(__middle, __last, *__first_cut);
                  __len22 = distance(__middle, __second_cut);
            }
            else {
                  __len22 = __len2 / 2;
                  advance(__second_cut, __len22);
                  __first_cut = upper_bound(__first, __middle, *__second_cut);
                  __len11 = distance(__first, __first_cut);
            }
            _BidirectionalIter __new_middle =
                  __rotate_adaptive(__first_cut, __middle, __second_cut,
                                    __len1 - __len11, __len22, __buffer,
                                    __buffer_size);
            __merge_adaptive(__first, __first_cut, __new_middle, __len11,
                             __len22, __buffer, __buffer_size);
            __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
                             __len2 - __len22, __buffer, __buffer_size);
          }
    }






  template<typename _BidirectionalIter, typename _Distance, typename _Pointer,
           typename _Compare>
    void
    __merge_adaptive(_BidirectionalIter __first,
                     _BidirectionalIter __middle,
                     _BidirectionalIter __last,
                     _Distance __len1, _Distance __len2,
                     _Pointer __buffer, _Distance __buffer_size,
                     _Compare __comp)
    {
          if (__len1 <= __len2 && __len1 <= __buffer_size) {
            _Pointer __buffer_end = copy(__first, __middle, __buffer);
            merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
          }
          else if (__len2 <= __buffer_size) {
            _Pointer __buffer_end = copy(__middle, __last, __buffer);
            __merge_backward(__first, __middle, __buffer, __buffer_end, __last,
                                             __comp);
          }
          else {
            _BidirectionalIter __first_cut = __first;
            _BidirectionalIter __second_cut = __middle;
            _Distance __len11 = 0;
            _Distance __len22 = 0;
            if (__len1 > __len2) {
                  __len11 = __len1 / 2;
                  advance(__first_cut, __len11);
                  __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
                  __len22 = distance(__middle, __second_cut);
            }
            else {
                  __len22 = __len2 / 2;
                  advance(__second_cut, __len22);
                  __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
                  __len11 = distance(__first, __first_cut);
            }
            _BidirectionalIter __new_middle =
                  __rotate_adaptive(__first_cut, __middle, __second_cut,
                                    __len1 - __len11, __len22, __buffer,
                                    __buffer_size);
            __merge_adaptive(__first, __first_cut, __new_middle, __len11,
                             __len22, __buffer, __buffer_size, __comp);
            __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
                             __len2 - __len22, __buffer, __buffer_size, __comp);
          }
    }
# 3510 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _BidirectionalIter>
    void
    inplace_merge(_BidirectionalIter __first,
                  _BidirectionalIter __middle,
                  _BidirectionalIter __last)
    {
      typedef typename iterator_traits<_BidirectionalIter>::value_type
          _ValueType;
      typedef typename iterator_traits<_BidirectionalIter>::difference_type
          _DistanceType;


     

     

      if (__first == __middle || __middle == __last)
        return;

      _DistanceType __len1 = distance(__first, __middle);
      _DistanceType __len2 = distance(__middle, __last);

      _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
      if (__buf.begin() == 0)
        __merge_without_buffer(__first, __middle, __last, __len1, __len2);
      else
        __merge_adaptive(__first, __middle, __last, __len1, __len2,
                         __buf.begin(), _DistanceType(__buf.size()));
    }
# 3561 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _BidirectionalIter, typename _Compare>
    void
    inplace_merge(_BidirectionalIter __first,
                  _BidirectionalIter __middle,
                  _BidirectionalIter __last,
                  _Compare __comp)
    {
      typedef typename iterator_traits<_BidirectionalIter>::value_type
          _ValueType;
      typedef typename iterator_traits<_BidirectionalIter>::difference_type
          _DistanceType;


     

     


      if (__first == __middle || __middle == __last)
        return;

      _DistanceType __len1 = distance(__first, __middle);
      _DistanceType __len2 = distance(__middle, __last);

      _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
      if (__buf.begin() == 0)
        __merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
      else
        __merge_adaptive(__first, __middle, __last, __len1, __len2,
                         __buf.begin(), _DistanceType(__buf.size()),
                         __comp);
    }






  template<typename _InputIter1, typename _InputIter2>
    bool
    includes(_InputIter1 __first1, _InputIter1 __last1,
             _InputIter2 __first2, _InputIter2 __last2)
    {

     
     
     


     


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

      return __first2 == __last2;
    }

  template<typename _InputIter1, typename _InputIter2, typename _Compare>
    bool
    includes(_InputIter1 __first1, _InputIter1 __last1,
             _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
    {

     
     
     


     



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

      return __first2 == __last2;
    }

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
    _OutputIter
    set_union(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2,
              _OutputIter __result)
    {

     
     
     

     


     


      while (__first1 != __last1 && __first2 != __last2) {
        if (*__first1 < *__first2) {
          *__result = *__first1;
          ++__first1;
        }
        else if (*__first2 < *__first1) {
          *__result = *__first2;
          ++__first2;
        }
        else {
          *__result = *__first1;
          ++__first1;
          ++__first2;
        }
        ++__result;
      }
      return copy(__first2, __last2, copy(__first1, __last1, __result));
    }

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
           typename _Compare>
    _OutputIter
    set_union(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2,
              _OutputIter __result, _Compare __comp)
    {

     
     
     


     

     



      while (__first1 != __last1 && __first2 != __last2) {
        if (__comp(*__first1, *__first2)) {
          *__result = *__first1;
          ++__first1;
        }
        else if (__comp(*__first2, *__first1)) {
          *__result = *__first2;
          ++__first2;
        }
        else {
          *__result = *__first1;
          ++__first1;
          ++__first2;
        }
        ++__result;
      }
      return copy(__first2, __last2, copy(__first1, __last1, __result));
    }

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
    _OutputIter
    set_intersection(_InputIter1 __first1, _InputIter1 __last1,
                     _InputIter2 __first2, _InputIter2 __last2,
                     _OutputIter __result)
    {

     
     
     

     


     


      while (__first1 != __last1 && __first2 != __last2)
        if (*__first1 < *__first2)
          ++__first1;
        else if (*__first2 < *__first1)
          ++__first2;
        else {
          *__result = *__first1;
          ++__first1;
          ++__first2;
          ++__result;
        }
      return __result;
    }

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
           typename _Compare>
    _OutputIter
    set_intersection(_InputIter1 __first1, _InputIter1 __last1,
                     _InputIter2 __first2, _InputIter2 __last2,
                     _OutputIter __result, _Compare __comp)
    {

     
     
     


     

     



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

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
    _OutputIter
    set_difference(_InputIter1 __first1, _InputIter1 __last1,
                   _InputIter2 __first2, _InputIter2 __last2,
                   _OutputIter __result)
    {

     
     
     

     


     


      while (__first1 != __last1 && __first2 != __last2)
        if (*__first1 < *__first2) {
          *__result = *__first1;
          ++__first1;
          ++__result;
        }
        else if (*__first2 < *__first1)
          ++__first2;
        else {
          ++__first1;
          ++__first2;
        }
      return copy(__first1, __last1, __result);
    }

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
           typename _Compare>
    _OutputIter
    set_difference(_InputIter1 __first1, _InputIter1 __last1,
                   _InputIter2 __first2, _InputIter2 __last2,
                   _OutputIter __result, _Compare __comp)
    {

     
     
     


     

     



      while (__first1 != __last1 && __first2 != __last2)
        if (__comp(*__first1, *__first2)) {
          *__result = *__first1;
          ++__first1;
          ++__result;
        }
        else if (__comp(*__first2, *__first1))
          ++__first2;
        else {
          ++__first1;
          ++__first2;
        }
      return copy(__first1, __last1, __result);
    }

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter>
    _OutputIter
    set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _OutputIter __result)
    {

     
     
     

     


     


      while (__first1 != __last1 && __first2 != __last2)
        if (*__first1 < *__first2) {
          *__result = *__first1;
          ++__first1;
          ++__result;
        }
        else if (*__first2 < *__first1) {
          *__result = *__first2;
          ++__first2;
          ++__result;
        }
        else {
          ++__first1;
          ++__first2;
        }
      return copy(__first2, __last2, copy(__first1, __last1, __result));
    }

  template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
           typename _Compare>
    _OutputIter
    set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _OutputIter __result,
                             _Compare __comp)
    {

     
     
     


     

     



      while (__first1 != __last1 && __first2 != __last2)
        if (__comp(*__first1, *__first2)) {
          *__result = *__first1;
          ++__first1;
          ++__result;
        }
        else if (__comp(*__first2, *__first1)) {
          *__result = *__first2;
          ++__first2;
          ++__result;
        }
        else {
          ++__first1;
          ++__first2;
        }
      return copy(__first2, __last2, copy(__first1, __last1, __result));
    }




  template<typename _ForwardIter>
    _ForwardIter
    max_element(_ForwardIter __first, _ForwardIter __last)
    {

     
     


      if (__first == __last) return __first;
      _ForwardIter __result = __first;
      while (++__first != __last)
        if (*__result < *__first)
          __result = __first;
      return __result;
    }

  template<typename _ForwardIter, typename _Compare>
    _ForwardIter
    max_element(_ForwardIter __first, _ForwardIter __last,
                _Compare __comp)
    {

     
     



      if (__first == __last) return __first;
      _ForwardIter __result = __first;
      while (++__first != __last)
        if (__comp(*__result, *__first)) __result = __first;
      return __result;
    }

  template<typename _ForwardIter>
    _ForwardIter
    min_element(_ForwardIter __first, _ForwardIter __last)
    {

     
     


      if (__first == __last) return __first;
      _ForwardIter __result = __first;
      while (++__first != __last)
        if (*__first < *__result)
          __result = __first;
      return __result;
    }

  template<typename _ForwardIter, typename _Compare>
    _ForwardIter
    min_element(_ForwardIter __first, _ForwardIter __last,
                _Compare __comp)
    {

     
     



      if (__first == __last) return __first;
      _ForwardIter __result = __first;
      while (++__first != __last)
        if (__comp(*__first, *__result))
          __result = __first;
      return __result;
    }




  template<typename _BidirectionalIter>
    bool
    next_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
    {

     
     


      if (__first == __last)
        return false;
      _BidirectionalIter __i = __first;
      ++__i;
      if (__i == __last)
        return false;
      __i = __last;
      --__i;

      for(;;) {
        _BidirectionalIter __ii = __i;
        --__i;
        if (*__i < *__ii) {
          _BidirectionalIter __j = __last;
          while (!(*__i < *--__j))
            {}
          iter_swap(__i, __j);
          reverse(__ii, __last);
          return true;
        }
        if (__i == __first) {
          reverse(__first, __last);
          return false;
        }
      }
    }

  template<typename _BidirectionalIter, typename _Compare>
    bool
    next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
                     _Compare __comp)
    {

     
     



      if (__first == __last)
        return false;
      _BidirectionalIter __i = __first;
      ++__i;
      if (__i == __last)
        return false;
      __i = __last;
      --__i;

      for(;;) {
        _BidirectionalIter __ii = __i;
        --__i;
        if (__comp(*__i, *__ii)) {
          _BidirectionalIter __j = __last;
          while (!__comp(*__i, *--__j))
            {}
          iter_swap(__i, __j);
          reverse(__ii, __last);
          return true;
        }
        if (__i == __first) {
          reverse(__first, __last);
          return false;
        }
      }
    }

  template<typename _BidirectionalIter>
    bool
    prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
    {

     
     


      if (__first == __last)
        return false;
      _BidirectionalIter __i = __first;
      ++__i;
      if (__i == __last)
        return false;
      __i = __last;
      --__i;

      for(;;) {
        _BidirectionalIter __ii = __i;
        --__i;
        if (*__ii < *__i) {
          _BidirectionalIter __j = __last;
          while (!(*--__j < *__i))
            {}
          iter_swap(__i, __j);
          reverse(__ii, __last);
          return true;
        }
        if (__i == __first) {
          reverse(__first, __last);
          return false;
        }
      }
    }

  template<typename _BidirectionalIter, typename _Compare>
    bool
    prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
                     _Compare __comp)
    {

     
     



      if (__first == __last)
        return false;
      _BidirectionalIter __i = __first;
      ++__i;
      if (__i == __last)
        return false;
      __i = __last;
      --__i;

      for(;;) {
        _BidirectionalIter __ii = __i;
        --__i;
        if (__comp(*__ii, *__i)) {
          _BidirectionalIter __j = __last;
          while (!__comp(*--__j, *__i))
            {}
          iter_swap(__i, __j);
          reverse(__ii, __last);
          return true;
        }
        if (__i == __first) {
          reverse(__first, __last);
          return false;
        }
      }
    }



  template<typename _InputIter, typename _ForwardIter>
    _InputIter
    find_first_of(_InputIter __first1, _InputIter __last1,
                  _ForwardIter __first2, _ForwardIter __last2)
    {

     
     
     



      for ( ; __first1 != __last1; ++__first1)
        for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
          if (*__first1 == *__iter)
            return __first1;
      return __last1;
    }

  template<typename _InputIter, typename _ForwardIter, typename _BinaryPredicate>
    _InputIter
    find_first_of(_InputIter __first1, _InputIter __last1,
                  _ForwardIter __first2, _ForwardIter __last2,
                  _BinaryPredicate __comp)
    {

     
     
     


     



      for ( ; __first1 != __last1; ++__first1)
        for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
          if (__comp(*__first1, *__iter))
            return __first1;
      return __last1;
    }
# 4203 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_algo.h" 3
  template<typename _ForwardIter1, typename _ForwardIter2>
    _ForwardIter1
    __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
               _ForwardIter2 __first2, _ForwardIter2 __last2,
               forward_iterator_tag, forward_iterator_tag)
    {
      if (__first2 == __last2)
        return __last1;
      else {
        _ForwardIter1 __result = __last1;
        while (1) {
          _ForwardIter1 __new_result
            = search(__first1, __last1, __first2, __last2);
          if (__new_result == __last1)
            return __result;
          else {
            __result = __new_result;
            __first1 = __new_result;
            ++__first1;
          }
        }
      }
    }

  template<typename _ForwardIter1, typename _ForwardIter2,
           typename _BinaryPredicate>
    _ForwardIter1
    __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
               _ForwardIter2 __first2, _ForwardIter2 __last2,
               forward_iterator_tag, forward_iterator_tag,
               _BinaryPredicate __comp)
    {
      if (__first2 == __last2)
        return __last1;
      else {
        _ForwardIter1 __result = __last1;
        while (1) {
          _ForwardIter1 __new_result
            = search(__first1, __last1, __first2, __last2, __comp);
          if (__new_result == __last1)
            return __result;
          else {
            __result = __new_result;
            __first1 = __new_result;
            ++__first1;
          }
        }
      }
    }


  template<typename _BidirectionalIter1, typename _BidirectionalIter2>
    _BidirectionalIter1
    __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
               _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
               bidirectional_iterator_tag, bidirectional_iterator_tag)
    {

     
     

      typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
      typedef reverse_iterator<_BidirectionalIter2> _RevIter2;

      _RevIter1 __rlast1(__first1);
      _RevIter2 __rlast2(__first2);
      _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
                                   _RevIter2(__last2), __rlast2);

      if (__rresult == __rlast1)
        return __last1;
      else {
        _BidirectionalIter1 __result = __rresult.base();
        advance(__result, -distance(__first2, __last2));
        return __result;
      }
    }

  template<typename _BidirectionalIter1, typename _BidirectionalIter2,
           typename _BinaryPredicate>
    _BidirectionalIter1
    __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
               _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
               bidirectional_iterator_tag, bidirectional_iterator_tag,
               _BinaryPredicate __comp)
    {

     
     

      typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
      typedef reverse_iterator<_BidirectionalIter2> _RevIter2;

      _RevIter1 __rlast1(__first1);
      _RevIter2 __rlast2(__first2);
      _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
                                   _RevIter2(__last2), __rlast2,
                                   __comp);

      if (__rresult == __rlast1)
        return __last1;
      else {
        _BidirectionalIter1 __result = __rresult.base();
        advance(__result, -distance(__first2, __last2));
        return __result;
      }
    }



  template<typename _ForwardIter1, typename _ForwardIter2>
    inline _ForwardIter1
    find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
             _ForwardIter2 __first2, _ForwardIter2 __last2)
    {

     
     
     



      return __find_end(__first1, __last1, __first2, __last2,
                        __iterator_category(__first1),
                        __iterator_category(__first2));
    }

  template<typename _ForwardIter1, typename _ForwardIter2,
           typename _BinaryPredicate>
    inline _ForwardIter1
    find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
             _ForwardIter2 __first2, _ForwardIter2 __last2,
             _BinaryPredicate __comp)
    {

     
     
     



      return __find_end(__first1, __last1, __first2, __last2,
                        __iterator_category(__first1),
                        __iterator_category(__first2),
                        __comp);
    }

}
# 70 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/algorithm" 2 3
# 57 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.tcc" 1 3
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.tcc" 3
#define _CPP_BITS_STRING_TCC 1

       
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.tcc" 3

namespace std
{
  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))/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>::_S_empty_rep_storage[
    (sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIter>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                   input_iterator_tag)
      {
        if (__beg == __end && __a == _Alloc())
          return _S_empty_rep()._M_refcopy();

        _CharT __buf[100];
        size_type __i = 0;
        while (__beg != __end && __i < sizeof(__buf) / sizeof(_CharT))
          {
            __buf[__i++] = *__beg;
            ++__beg;
          }
        _Rep* __r = _Rep::_S_create(__i, __a);
        traits_type::copy(__r->_M_refdata(), __buf, __i);
        __r->_M_length = __i;
        try
          {



            for (;;)
              {
                _CharT* __p = __r->_M_refdata() + __r->_M_length;
                _CharT* __last = __r->_M_refdata() + __r->_M_capacity;
                for (;;)
                  {
                    if (__beg == __end)
                      {
                        __r->_M_length = __p - __r->_M_refdata();
                        *__p = _Rep::_S_terminal;
                        return __r->_M_refdata();
                      }
                    if (__p == __last)
                      break;
                    *__p++ = *__beg;
                    ++__beg;
                  }

                size_type __len = __p - __r->_M_refdata();
                _Rep* __another = _Rep::_S_create(__len + 1, __a);
                traits_type::copy(__another->_M_refdata(),
                                  __r->_M_refdata(), __len);
                __r->_M_destroy(__a);
                __r = __another;
                __r->_M_length = __len;
              }
          }
        catch(...)
          {
            __r->_M_destroy(__a);
            throw;
          }
        return 0;
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template <class _InIter>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                   forward_iterator_tag)
      {
        if (__beg == __end && __a == _Alloc())
          return _S_empty_rep()._M_refcopy();


        if (__builtin_expect(__beg == _InIter(), 0))
          __throw_logic_error("attempt to create string with null pointer");

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


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

        __r->_M_refdata()[__dnew] = _Rep::_S_terminal;
        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_refcopy();


      _Rep* __r = _Rep::_S_create(__n, __a);
      try
        {
          if (__n)
            traits_type::assign(__r->_M_refdata(), __n, __c);
        }
      catch(...)
        {
          __r->_M_destroy(__a);
          throw;
        }
      __r->_M_length = __n;
      __r->_M_refdata()[__n] = _Rep::_S_terminal;
      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())
    { }

  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_check(__pos),
                               __str._M_fold(__pos, __n), _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_check(__pos),
                               __str._M_fold(__pos, __n), __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 _InputIter>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(_InputIter __beg, _InputIter __end, const _Alloc& __a)
    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
    { }

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

          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 basic_string& __str, size_type __pos, size_type __n)
     {
       const size_type __strsize = __str.size();
       if (__pos > __strsize)
         __throw_out_of_range("basic_string::assign");
       const bool __testn = __n < __strsize - __pos;
       const size_type __newsize = __testn ? __n : __strsize - __pos;
       return this->assign(__str._M_data() + __pos, __newsize);
     }

   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     assign(const _CharT* __s, size_type __n)
     {
       if (__n > this->max_size())
         __throw_length_error("basic_string::assign");
       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
           || less<const _CharT*>()(_M_data() + this->size(), __s))
         return _M_replace_safe(_M_ibegin(), _M_iend(), __s, __s + __n);
       else
         {

           const size_type __pos = __s - _M_data();
           if (__pos >= __n)
             traits_type::copy(_M_data(), __s, __n);
           else if (__pos)
             traits_type::move(_M_data(), __s, __n);
           _M_rep()->_M_length = __n;
           _M_data()[__n] = _Rep::_S_terminal;
           return *this;
         }
     }

   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     insert(size_type __pos1, const basic_string& __str,
            size_type __pos2, size_type __n)
     {
       const size_type __strsize = __str.size();
       if (__pos2 > __strsize)
         __throw_out_of_range("basic_string::insert");
       const bool __testn = __n < __strsize - __pos2;
       const size_type __newsize = __testn ? __n : __strsize - __pos2;
       return this->insert(__pos1, __str._M_data() + __pos2, __newsize);
     }

   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)
     {
       const size_type __size = this->size();
       if (__pos > __size)
         __throw_out_of_range("basic_string::insert");
       if (__size > this->max_size() - __n)
         __throw_length_error("basic_string::insert");
       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
           || less<const _CharT*>()(_M_data() + __size, __s))
         return _M_replace_safe(_M_ibegin() + __pos, _M_ibegin() + __pos,
                                __s, __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)
             traits_type::copy(__p, __s, __n);
           else if (__s >= __p)
             traits_type::copy(__p, __s + __n, __n);
           else
             {
               traits_type::copy(__p, __s, __p - __s);
               traits_type::copy(__p + (__p-__s), __p + __n, __n - (__p-__s));
             }
           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)
     {
       const size_type __size = this->size();
       if (__pos > __size)
         __throw_out_of_range("basic_string::replace");
       const bool __testn1 = __n1 < __size - __pos;
       const size_type __foldn1 = __testn1 ? __n1 : __size - __pos;
       if (__size - __foldn1 > this->max_size() - __n2)
         __throw_length_error("basic_string::replace");
       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
           || less<const _CharT*>()(_M_data() + __size, __s))
         return _M_replace_safe(_M_ibegin() + __pos,
                                _M_ibegin() + __pos + __foldn1, __s, __s + __n2);

       else
         return _M_replace(_M_ibegin() + __pos, _M_ibegin() + __pos + __foldn1,
                           __s, __s + __n2,
                           typename iterator_traits<const _CharT*>::iterator_category());
     }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_destroy(const _Alloc& __a) throw ()
    {
      size_type __size = sizeof(_Rep) + (_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()->_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)
    {
      size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;
      const _CharT* __src = _M_data() + __pos + __len1;
      const size_type __how_much = __old_size - __pos - __len1;

      if (_M_rep()->_M_is_shared() || __new_size > capacity())
        {

          allocator_type __a = get_allocator();


          const size_type __pagesize = 4096;
          const size_type __malloc_header_size = 4 * sizeof (void*);

          const size_type __page_capacity = (__pagesize - __malloc_header_size
                                             - sizeof(_Rep) - sizeof(_CharT))
                                             / sizeof(_CharT);
          _Rep* __r;
          if (__new_size > capacity() && __new_size > __page_capacity)

            __r = _Rep::_S_create(__new_size > 2*capacity() ?
                                  __new_size : 2*capacity(), __a);
          else
            __r = _Rep::_S_create(__new_size, __a);
          try
            {
              if (__pos)
                traits_type::copy(__r->_M_refdata(), _M_data(), __pos);
              if (__how_much)
                traits_type::copy(__r->_M_refdata() + __pos + __len2,
                                  __src, __how_much);
            }
          catch(...)
            {
              __r->_M_dispose(get_allocator());
              throw;
            }
          _M_rep()->_M_dispose(__a);
          _M_data(__r->_M_refdata());
      }
      else if (__how_much && __len1 != __len2)
        {

          traits_type::move(_M_data() + __pos + __len2, __src, __how_much);
        }
      _M_rep()->_M_set_sharable();
      _M_rep()->_M_length = __new_size;
      _M_data()[__new_size] = _Rep::_S_terminal;

    }

  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->max_size())
            __throw_length_error("basic_string::reserve");

          if (__res < this->size())
            __res = this->size();
          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
        {
          basic_string __tmp1(_M_ibegin(), _M_iend(), __s.get_allocator());
          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_t __capacity, const _Alloc& __alloc)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;


      if (__capacity > _S_max_size)



        __throw_length_error("basic_string::_S_create");




      size_t __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
# 532 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_string.tcc" 3
      const size_t __pagesize = 4096;
      const size_t __subpagesize = 128;
      const size_t __malloc_header_size = 4 * sizeof (void*);
      if ((__size + __malloc_header_size) > __pagesize)
        {
          size_t __extra =
            (__pagesize - ((__size + __malloc_header_size) % __pagesize))
            % __pagesize;
          __capacity += __extra / sizeof(_CharT);
          __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
        }
      else if (__size > __subpagesize)
        {
          size_t __extra =
            (__subpagesize - ((__size + __malloc_header_size) % __subpagesize))
            % __subpagesize;
          __capacity += __extra / sizeof(_CharT);
          __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();
      __p->_M_length = 0;
      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 = _M_length + __res;

      const size_type __pagesize = 4096;
      const size_type __malloc_header_size = 4 * sizeof (void*);

      const size_type __page_capacity =
        (__pagesize - __malloc_header_size - sizeof(_Rep) - sizeof(_CharT))
        / sizeof(_CharT);
      _Rep* __r;
      if (__requested_cap > _M_capacity && __requested_cap > __page_capacity)

        __r = _Rep::_S_create(__requested_cap > 2*_M_capacity ?
                              __requested_cap : 2*_M_capacity, __alloc);
      else
        __r = _Rep::_S_create(__requested_cap, __alloc);

      if (_M_length)
        {
          try
            { traits_type::copy(__r->_M_refdata(), _M_refdata(), _M_length); }
          catch(...)
            {
              __r->_M_destroy(__alloc);
              throw;
            }
        }
      __r->_M_length = _M_length;
      __r->_M_refdata()[_M_length] = _Rep::_S_terminal;
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
    {
      if (__n > max_size())
        __throw_length_error("basic_string::resize");
      size_type __size = this->size();
      if (__size < __n)
        this->append(__n - __size, __c);
      else if (__n < __size)
        this->erase(__n);

    }




  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIter>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace(iterator __i1, iterator __i2, _InputIter __k1,
                 _InputIter __k2, input_iterator_tag)
      {

        basic_string __s(__k1, __k2);
        return _M_replace_safe(__i1, __i2, __s._M_ibegin(), __s._M_iend());
      }




  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _ForwardIter>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace_safe(iterator __i1, iterator __i2, _ForwardIter __k1,
                      _ForwardIter __k2)
      {
        size_type __dnew = static_cast<size_type>(std::distance(__k1, __k2));
        size_type __dold = __i2 - __i1;
        size_type __dmax = this->max_size();

        if (__dmax <= __dnew)
          __throw_length_error("basic_string::_M_replace");
        size_type __off = __i1 - _M_ibegin();
        _M_mutate(__off, __dold, __dnew);


        if (__dnew)
          _S_copy_chars(_M_data() + __off, __k1, __k2);

        return *this;
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    replace(size_type __pos1, size_type __n1, const basic_string& __str,
            size_type __pos2, size_type __n2)
    {
      const size_type __strsize = __str.size();
      if (__pos2 > __strsize)
        __throw_out_of_range("basic_string::replace");
      const bool __testn2 = __n2 < __strsize - __pos2;
      const size_type __foldn2 = __testn2 ? __n2 : __strsize - __pos2;
      return this->replace(__pos1, __n1,
                           __str._M_data() + __pos2, __foldn2);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const basic_string& __str)
    {



      size_type __size = __str.size();
      size_type __len = __size + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return _M_replace_safe(_M_iend(), _M_iend(), __str._M_ibegin(),
                             __str._M_iend());
    }

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



      size_type __len = std::min(size_type(__str.size() - __pos),
                                 __n) + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return _M_replace_safe(_M_iend(), _M_iend(), __str._M_check(__pos),
                             __str._M_fold(__pos, __n));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const _CharT* __s, size_type __n)
    {
      size_type __len = __n + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return _M_replace_safe(_M_iend(), _M_iend(), __s, __s + __n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(size_type __n, _CharT __c)
    {
      size_type __len = __n + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
       return this->replace(_M_iend(), _M_iend(), __n, __c);
    }

  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;
      __size_type __len = _Traits::length(__lhs);
      __string_type __str;
      __str.reserve(__len + __rhs.size());
      __str.append(__lhs, __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;
      __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>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    replace(iterator __i1, iterator __i2, size_type __n2, _CharT __c)
    {
      size_type __n1 = __i2 - __i1;
      size_type __off1 = __i1 - _M_ibegin();
      if (max_size() - (this->size() - __n1) <= __n2)
        __throw_length_error("basic_string::replace");
      _M_mutate (__off1, __n1, __n2);

      if (__n2)
        traits_type::assign(_M_data() + __off1, __n2, __c);
      return *this;
    }

  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
    {
      if (__pos > this->size())
        __throw_out_of_range("basic_string::copy");

      if (__n > this->size() - __pos)
        __n = this->size() - __pos;

      traits_type::copy(__s, _M_data() + __pos, __n);

      return __n;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      size_t __xpos = __pos;
      const _CharT* __data = _M_data();
      for (; __xpos + __n <= __size; ++__xpos)
        if (traits_type::compare(__data + __xpos, __s, __n) == 0)
          return __xpos;
      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 __size = this->size();
      size_type __ret = npos;
      if (__pos < __size)
        {
          const _CharT* __data = _M_data();
          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
    {
      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)
        {
          size_t __xpos = __size - 1;
          if (__xpos > __pos)
            __xpos = __pos;

          for (++__xpos; __xpos-- > 0; )
            if (traits_type::eq(_M_data()[__xpos], __c))
              return __xpos;
        }
      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
    {
      size_t __xpos = __pos;
      for (; __xpos < this->size(); ++__xpos)
        if (!traits_type::find(__s, __n, _M_data()[__xpos]))
          return __xpos;
      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
    {
      size_t __xpos = __pos;
      for (; __xpos < this->size(); ++__xpos)
        if (!traits_type::eq(_M_data()[__xpos], __c))
          return __xpos;
      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
    {
      size_type __size = this->size();
      size_type __osize = __str.size();
      if (__pos > __size)
        __throw_out_of_range("basic_string::compare");

      size_type __rsize= std::min(size_type(__size - __pos), __n);
      size_type __len = std::min(__rsize, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
      if (!__r)
        __r = __rsize - __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
    {
      size_type __size = this->size();
      size_type __osize = __str.size();
      if (__pos1 > __size || __pos2 > __osize)
        __throw_out_of_range("basic_string::compare");

      size_type __rsize = std::min(size_type(__size - __pos1), __n1);
      size_type __rosize = std::min(size_type(__osize - __pos2), __n2);
      size_type __len = std::min(__rsize, __rosize);
      int __r = traits_type::compare(_M_data() + __pos1,
                                     __str.data() + __pos2, __len);
      if (!__r)
        __r = __rsize - __rosize;
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(const _CharT* __s) const
    {
      size_type __size = this->size();
      size_type __osize = traits_type::length(__s);
      size_type __len = std::min(__size, __osize);
      int __r = traits_type::compare(_M_data(), __s, __len);
      if (!__r)
        __r = __size - __osize;
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s) const
    {
      size_type __size = this->size();
      if (__pos > __size)
        __throw_out_of_range("basic_string::compare");

      size_type __osize = traits_type::length(__s);
      size_type __rsize = std::min(size_type(__size - __pos), __n1);
      size_type __len = std::min(__rsize, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
        __r = __rsize - __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
    {
      size_type __size = this->size();
      if (__pos > __size)
        __throw_out_of_range("basic_string::compare");

      size_type __rsize = std::min(size_type(__size - __pos), __n1);
      size_type __len = std::min(__rsize, __n2);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
        __r = __rsize - __n2;
      return __r;
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    _S_string_copy(const basic_string<_CharT, _Traits, _Alloc>& __str,
                   _CharT* __buf, typename _Alloc::size_type __bufsiz)
    {
      typedef typename _Alloc::size_type size_type;
      size_type __strsize = __str.size();
      size_type __bytes = std::min(__strsize, __bufsiz - 1);
      _Traits::copy(__buf, __str.data(), __bytes);
      __buf[__bytes] = _CharT();
    }





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


}
# 58 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/string" 2 3
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_classes.h" 2 3


namespace std
{
  class __locale_cache_base;
  template<typename _Facet> class __locale_cache;


  class locale
  {
  public:

    typedef unsigned int category;


    class facet;
    class id;
    class _Impl;

    friend class facet;
    friend class _Impl;

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

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

    template<typename _Facet>
      friend const __locale_cache<_Facet>&
      __use_cache(const locale&);



    static const category none = 0;
    static const category ctype = 1L << 0;
    static const category numeric = 1L << 1;
    static const category collate = 1L << 2;
    static const category time = 1L << 3;
    static const category monetary = 1L << 4;
    static const category messages = 1L << 5;
    static const category all = (ctype | numeric | collate |
                                           time | monetary | messages);


    locale() throw();

    locale(const locale& __other) throw();

    explicit
    locale(const char* __s);

    locale(const locale& __base, const char* __s, category __cat);

    locale(const locale& __base, const locale& __add, category __cat);

    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);

    ~locale() throw();

    const locale&
    operator=(const locale& __other) throw();

    template<typename _Facet>
      locale
      combine(const locale& __other) const;


    string
    name() const;

    bool
    operator==(const locale& __other) const throw ();

    inline bool
    operator!=(const locale& __other) const throw ()
    { return !(this->operator==(__other)); }

    template<typename _Char, typename _Traits, typename _Alloc>
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
                 const basic_string<_Char, _Traits, _Alloc>& __s2) const;


    static locale
    global(const locale&);

    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;






    static const size_t _S_categories_size = 6;






    static const size_t _S_extra_categories_size = 6;





    static const char* _S_categories[_S_categories_size
                                      + _S_extra_categories_size];

    explicit
    locale(_Impl*) throw();

    static inline void
    _S_initialize()
    {
      if (!_S_classic)
        classic();
    }

    static category
    _S_normalize_category(category);

    void
    _M_coalesce(const locale& __base, const locale& __add, category __cat);
  };



  class locale::_Impl
  {
  public:

    friend class locale;
    friend class locale::facet;

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

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

    template<typename _Facet>
      friend const __locale_cache<_Facet>&
      __use_cache(const locale&);

  private:

    _Atomic_word _M_references;
    facet** _M_facets;
    size_t _M_facets_size;

    char* _M_names[_S_categories_size
                                                 + _S_extra_categories_size];
    static const locale::id* const _S_id_ctype[];
    static const locale::id* const _S_id_numeric[];
    static const locale::id* const _S_id_collate[];
    static const locale::id* const _S_id_time[];
    static const locale::id* const _S_id_monetary[];
    static const locale::id* const _S_id_messages[];
    static const locale::id* const* const _S_facet_categories[];

    inline void
    _M_add_reference() throw()
    { __atomic_add(&_M_references, 1); }

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

    _Impl(const _Impl&, size_t);
    _Impl(const char*, size_t);
    _Impl(facet**, size_t, bool);

   ~_Impl() throw();

    _Impl(const _Impl&);

    void
    operator=(const _Impl&);

    inline bool
    _M_check_same_name()
    {
      bool __ret = true;
      for (size_t __i = 0;
           __ret && __i < _S_categories_size + _S_extra_categories_size - 1;
           ++__i)
        __ret &= (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*, facet*);

    template<typename _Facet>
      inline void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }




    inline __locale_cache_base*
      _M_get_cache(size_t __index)
      {
        return (__locale_cache_base*)_M_facets[__index + _M_facets_size];
      }



    void
    _M_install_cache(__locale_cache_base* __cache, int __id)
    {
      _M_facets[__id + _M_facets_size] =
        reinterpret_cast<locale::facet*>(__cache);
    }

  };

  template<typename _Facet>
    locale::locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);

      char* _M_tmp_names[_S_categories_size + _S_extra_categories_size];
      size_t __i = 0;
      try
        {
          for (; __i < _S_categories_size
                       + _S_extra_categories_size; ++__i)
            {
              _M_tmp_names[__i] = new char[2];
              strcpy(_M_tmp_names[__i], "*");
            }
          _M_impl->_M_install_facet(&_Facet::id, __f);
        }
      catch(...)
        {
          _M_impl->_M_remove_reference();
          for (size_t __j = 0; __j < __i; ++__j)
            delete [] _M_tmp_names[__j];
          throw;
        }

      for (size_t __k = 0; __k < _S_categories_size
                                 + _S_extra_categories_size; ++__k)
        {
          delete [] _M_impl->_M_names[__k];
          _M_impl->_M_names[__k] = _M_tmp_names[__k];
        }
    }



  class locale::facet
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    _Atomic_word _M_references;

  protected:

    static __c_locale _S_c_locale;


    static char _S_c_name[2];

    explicit
    facet(size_t __refs = 0) throw();

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

  private:
    void
    _M_add_reference() throw();

    void
    _M_remove_reference() throw();

    facet(const facet&);

    void
    operator=(const facet&);
  };



  class locale::id
  {
  private:
    friend class locale;
    friend class locale::_Impl;
    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);
    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw ();




    mutable size_t _M_index;


    static _Atomic_word _S_highwater;

    void
    operator=(const id&);

    id(const id&);

  public:


    id();

    inline size_t
    _M_id() const
    {
      if (!_M_index)
        _M_index = 1 + __exchange_and_add(&_S_highwater, 1);
      return _M_index - 1;
    }
  };
}
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 2 3

namespace std
{




  enum _Ios_Fmtflags { _M_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 { _M_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 { _M_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 { _M_ios_seekdir_end = 1L << 16 };
# 158 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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:
      enum { _M_bufsize = 256 };
      char _M_name[_M_bufsize];

    };
# 212 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    typedef _Ios_Fmtflags fmtflags;

    static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha);

    static const fmtflags dec = fmtflags(__ios_flags::_S_dec);

    static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed);

    static const fmtflags hex = fmtflags(__ios_flags::_S_hex);



    static const fmtflags internal = fmtflags(__ios_flags::_S_internal);


    static const fmtflags left = fmtflags(__ios_flags::_S_left);

    static const fmtflags oct = fmtflags(__ios_flags::_S_oct);


    static const fmtflags right = fmtflags(__ios_flags::_S_right);

    static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific);


    static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase);


    static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint);

    static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos);

    static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws);

    static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf);


    static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase);

    static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);

    static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield);

    static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield);
# 269 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    typedef _Ios_Iostate iostate;


    static const iostate badbit = iostate(__ios_flags::_S_badbit);

    static const iostate eofbit = iostate(__ios_flags::_S_eofbit);



    static const iostate failbit = iostate(__ios_flags::_S_failbit);

    static const iostate goodbit = iostate(0);
# 296 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    typedef _Ios_Openmode openmode;

    static const openmode app = openmode(__ios_flags::_S_app);

    static const openmode ate = openmode(__ios_flags::_S_ate);




    static const openmode binary = openmode(__ios_flags::_S_bin);

    static const openmode in = openmode(__ios_flags::_S_in);

    static const openmode out = openmode(__ios_flags::_S_out);

    static const openmode trunc = openmode(__ios_flags::_S_trunc);
# 323 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    typedef _Ios_Seekdir seekdir;

    static const seekdir beg = seekdir(0);

    static const seekdir cur = seekdir(1);

    static const seekdir end = seekdir(2);
# 345 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };




    typedef void (*event_callback) (event, ios_base&, int);




    void
    register_callback(event_callback __fn, int __index);

  protected:






    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;
    iostate _M_exception;
    iostate _M_streambuf_state;




    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      _Atomic_word _M_refcount;

      _Callback_list(ios_base::event_callback __fn, int __index,
                     _Callback_list* __cb)
      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void
      _M_add_reference() { __atomic_add(&_M_refcount, 1); }


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

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void);


    struct _Words
    {
      void* _M_pword;
      long _M_iword;
      _Words() : _M_pword(0), _M_iword(0) { }
    };


    _Words _M_word_zero;



    static const int _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);


    locale _M_ios_locale;

    void
    _M_init();

  public:





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

      static void
      _S_ios_create(bool __sync);

      static void
      _S_ios_destroy();




      static bool
      _S_initialized() { return _S_ios_base_init; }

    private:
      static int _S_ios_base_init;
      static bool _S_synced_with_stdio;
    };






    inline fmtflags
    flags() const { return _M_flags; }
# 481 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    inline fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 497 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    inline fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 514 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    inline fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }







    inline void
    unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
# 541 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    inline streamsize
    precision() const { return _M_precision; }






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







    inline streamsize
    width() const { return _M_width; }






    inline streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }
# 590 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 602 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc);
# 613 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    inline locale
    getloc() const { return _M_ios_locale; }
# 623 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ios_base.h" 3
    inline const locale&
    _M_getloc() const { return _M_ios_locale; }





    static int
    xalloc() throw();




    inline long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
                        ? _M_word[__ix] : _M_grow_words(__ix);
      return __word._M_iword;
    }




    inline void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
                        ? _M_word[__ix] : _M_grow_words(__ix);
      return __word._M_pword;
    }






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

}
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
#define _CPP_STREAMBUF 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3







namespace std
{





  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_ios<_CharT, _Traits>& _ios,
                      basic_streambuf<_CharT, _Traits>* __sbin,
                      basic_streambuf<_CharT, _Traits>* __sbout);
# 124 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
# 147 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      typedef ctype<char_type> __ctype_type;
      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef typename traits_type::state_type __state_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<>(basic_ios<char_type, traits_type>& __ios,
                          __streambuf_type* __sbin,__streambuf_type* __sbout);

    protected:
# 171 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      char_type* _M_buf;






      size_t _M_buf_size;






      size_t _M_buf_size_opt;







      bool _M_buf_unified;
# 205 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;







      ios_base::openmode _M_mode;






      locale _M_buf_locale;






      bool _M_buf_locale_init;
# 245 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      static const size_t _S_pback_size = 1;
      char_type _M_pback[_S_pback_size];
      char_type* _M_pback_cur_save;
      char_type* _M_pback_end_save;
      bool _M_pback_init;







      fpos<__state_type> _M_pos;




      void
      _M_pback_create()
      {
        if (!_M_pback_init)
          {
            size_t __dist = _M_in_end - _M_in_cur;
            size_t __len = min(_S_pback_size, __dist);
            traits_type::copy(_M_pback, _M_in_cur, __len);
            _M_pback_cur_save = _M_in_cur;
            _M_pback_end_save = _M_in_end;
            this->setg(_M_pback, _M_pback, _M_pback + __len);
            _M_pback_init = true;
          }
      }




      void
      _M_pback_destroy() throw()
      {
        if (_M_pback_init)
          {

            size_t __off_cur = _M_in_cur - _M_pback;


            size_t __off_end = 0;
            size_t __pback_len = _M_in_end - _M_pback;
            size_t __save_len = _M_pback_end_save - _M_buf;
            if (__pback_len > __save_len)
              __off_end = __pback_len - __save_len;

            this->setg(_M_buf, _M_pback_cur_save + __off_cur,
                       _M_pback_end_save + __off_end);
            _M_pback_cur_save = __null;
            _M_pback_end_save = __null;
            _M_pback_init = false;
          }
      }



      void
      _M_in_cur_move(off_type __n)
      {
        bool __testout = _M_out_cur;
        _M_in_cur += __n;
        if (__testout && _M_buf_unified)
          _M_out_cur += __n;
      }
# 322 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      void
      _M_out_cur_move(off_type __n)
      {
        bool __testin = _M_in_cur;

        _M_out_cur += __n;
        if (__testin && _M_buf_unified)
          _M_in_cur += __n;
        if (_M_out_cur > _M_out_end)
          {
            _M_out_end = _M_out_cur;

            if (__testin)
              _M_in_end += __n;
          }
      }




      off_type
      _M_out_buf_size()
      {
        off_type __ret = 0;
        if (_M_out_cur)
          {

            if (_M_out_beg == _M_buf)
              __ret = _M_out_beg + _M_buf_size - _M_out_cur;

            else
              __ret = _M_out_end - _M_out_cur;
          }
        return __ret;
      }

  public:

      virtual
      ~basic_streambuf()
      {
        _M_buf_unified = false;
        _M_buf_size = 0;
        _M_buf_size_opt = 0;
        _M_mode = ios_base::openmode(0);
      }
# 377 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      locale
      pubimbue(const locale &__loc)
      {
        locale __tmp(this->getloc());
        this->imbue(__loc);
        _M_buf_locale = __loc;
        return __tmp;
      }
# 394 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 407 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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(); }
# 434 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      streamsize
      in_avail()
      {
        streamsize __ret;
        if (_M_in_cur && _M_in_cur < _M_in_end)
          {
            if (_M_pback_init)
              {
                size_t __save_len = _M_pback_end_save - _M_pback_cur_save;
                size_t __pback_len = _M_in_cur - _M_pback;
                __ret = __save_len - __pback_len;
              }
            else
              __ret = this->egptr() - this->gptr();
          }
        else
          __ret = this->showmanyc();
        return __ret;
      }
# 461 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      int_type
      snextc()
      {
        int_type __eof = traits_type::eof();
        return (traits_type::eq_int_type(this->sbumpc(), __eof)
                ? __eof : this->sgetc());
      }
# 477 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      int_type
      sbumpc();
# 488 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      int_type
      sgetc()
      {
        int_type __ret;
        if (_M_in_cur && _M_in_cur < _M_in_end)
          __ret = traits_type::to_int_type(*(this->gptr()));
        else
          __ret = this->underflow();
        return __ret;
      }
# 507 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 521 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      int_type
      sputbackc(char_type __c);
# 533 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      int_type
      sungetc();
# 549 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      int_type
      sputc(char_type __c);
# 563 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 577 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      basic_streambuf()
      : _M_buf(__null), _M_buf_size(0), _M_buf_size_opt(8192),
      _M_buf_unified(false), _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_mode(ios_base::openmode(0)), _M_buf_locale(locale()),
      _M_pback_cur_save(0), _M_pback_end_save(0),
      _M_pback_init(false)
      { }
# 598 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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; }
# 614 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 625 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
        if (!(_M_mode & ios_base::in) && __gbeg && __gnext && __gend)
          _M_mode = _M_mode | ios_base::in;
      }
# 647 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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; }
# 663 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 673 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
        _M_out_beg = _M_out_cur = __pbeg;
        _M_out_end = __pend;
        if (!(_M_mode & ios_base::out) && __pbeg && __pend)
          _M_mode = _M_mode | ios_base::out;
      }
# 696 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual void
      imbue(const locale&)
      { }
# 711 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 722 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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)); }
# 734 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
              ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 747 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual int
      sync() { return 0; }
# 769 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 785 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 807 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 820 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual int_type
      uflow()
      {
        int_type __ret = traits_type::eof();
        bool __testeof = traits_type::eq_int_type(this->underflow(), __ret);
        bool __testpending = _M_in_cur && _M_in_cur < _M_in_end;
        if (!__testeof && __testpending)
          {
            __ret = traits_type::to_int_type(*_M_in_cur);
            ++_M_in_cur;
            if (_M_buf_unified && _M_mode & ios_base::out)
              ++_M_out_cur;
          }
        return __ret;
      }
# 846 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual int_type
      pbackfail(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 864 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 889 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
      virtual int_type
      overflow(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 920 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 3
    private:
      basic_streambuf(const __streambuf_type&) { };

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

    };
}


#define export 


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/streambuf.tcc" 1 3
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/streambuf.tcc" 3
#define _CPP_BITS_STREAMBUF_TCC 1

       
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/streambuf.tcc" 3

namespace std
{
  template<typename _CharT, typename _Traits>
    const size_t
    basic_streambuf<_CharT, _Traits>::_S_pback_size;

  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sbumpc()
    {
      int_type __ret;
      if (_M_in_cur && _M_in_cur < _M_in_end)
        {
          char_type __c = *(this->gptr());
          _M_in_cur_move(1);
          __ret = traits_type::to_int_type(__c);
        }
      else
        __ret = this->uflow();
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sputbackc(char_type __c)
    {
      int_type __ret;
      bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;
      if (!__testpos || !traits_type::eq(__c, this->gptr()[-1]))
        __ret = this->pbackfail(traits_type::to_int_type(__c));
      else
        {
          _M_in_cur_move(-1);
          __ret = traits_type::to_int_type(*this->gptr());
        }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sungetc()
    {
      int_type __ret;
      if (_M_in_cur && _M_in_beg < _M_in_cur)
        {
          _M_in_cur_move(-1);
          __ret = traits_type::to_int_type(*_M_in_cur);
        }
      else
        __ret = this->pbackfail();
      return __ret;
    }






  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sputc(char_type __c)
    {
      int_type __ret;
      if (_M_out_buf_size())
        {
          *_M_out_cur = __c;
          _M_out_cur_move(1);
          __ret = traits_type::to_int_type(__c);
        }
      else
        __ret = this->overflow(traits_type::to_int_type(__c));
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
        {
          size_t __buf_len = _M_in_end - _M_in_cur;
          if (__buf_len > 0)
            {
              size_t __remaining = __n - __ret;
              size_t __len = min(__buf_len, __remaining);
              traits_type::copy(__s, _M_in_cur, __len);
              __ret += __len;
              __s += __len;
              _M_in_cur_move(__len);
            }

          if (__ret < __n)
            {
              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)
        {
          off_type __buf_len = _M_out_buf_size();
          if (__buf_len > 0)
            {
              off_type __remaining = __n - __ret;
              off_type __len = min(__buf_len, __remaining);
              traits_type::copy(_M_out_cur, __s, __len);
              __ret += __len;
              __s += __len;
              _M_out_cur_move(__len);
            }

          if (__ret < __n)
            {
              int_type __c = this->overflow(traits_type::to_int_type(*__s));
              if (!traits_type::eq_int_type(__c, traits_type::eof()))
                {
                  ++__ret;
                  ++__s;
                }
              else
                break;
            }
        }
      return __ret;
    }





  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_ios<_CharT, _Traits>&,
                      basic_streambuf<_CharT, _Traits>* __sbin,
                      basic_streambuf<_CharT, _Traits>* __sbout)
  {
    streamsize __ret = 0;
    typename _Traits::int_type __c = __sbin->sgetc();
    while (!_Traits::eq_int_type(__c, _Traits::eof()))
      {
        const size_t __n = __sbin->_M_in_end - __sbin->_M_in_cur;
        if (__n > 1)
          {
            const size_t __wrote = __sbout->sputn(__sbin->_M_in_cur, __n);
            __sbin->_M_in_cur_move(__wrote);
            __ret += __wrote;
            if (__wrote < __n)
              break;
            __c = __sbin->underflow();
          }
        else
          {
            __c = __sbout->sputc(_Traits::to_char_type(__c));
            if (_Traits::eq_int_type(__c, _Traits::eof()))
              break;
            ++__ret;
            __c = __sbin->snextc();
          }
      }
    return __ret;
  }





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


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


}
# 934 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/streambuf" 2 3
# 51 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 1 3
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
#define _CPP_BITS_BASICIOS_H 1

       
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/streambuf_iterator.h" 1 3
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/streambuf_iterator.h" 3
#define _CPP_BITS_STREAMBUF_ITERATOR_H 1

       
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/streambuf_iterator.h" 3





namespace std
{

  template<typename _CharT, typename _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
                      _CharT*, _CharT&>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

    private:







      mutable streambuf_type* _M_sbuf;
      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++()
      {
        const int_type __eof = traits_type::eof();
        if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof))
          _M_sbuf = 0;
        else
          _M_c = __eof;
        return *this;
      }

      istreambuf_iterator
      operator++(int)
      {
        const int_type __eof = traits_type::eof();
        istreambuf_iterator __old = *this;
        if (_M_sbuf
            && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()),
                                        __eof))
          _M_sbuf = 0;
        else
          _M_c = __eof;
        return __old;
      }




      bool
      equal(const istreambuf_iterator& __b) const
      {
        const int_type __eof = traits_type::eof();
        bool __thiseof = traits_type::eq_int_type(_M_get(), __eof);
        bool __beof = traits_type::eq_int_type(__b._M_get(), __eof);
        return (__thiseof && __beof || (!__thiseof && !__beof));
      }


    private:
      int_type
      _M_get() const
      {
        const int_type __eof = traits_type::eof();
        int_type __ret = __eof;
        if (_M_sbuf)
          {
            if (!traits_type::eq_int_type(_M_c, __eof))
              __ret = _M_c;
            else
              if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof))
                _M_sbuf = 0;
          }
        return __ret;
      }
    };

  template<typename _CharT, typename _Traits>
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
               const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }

  template<typename _CharT, typename _Traits>
    inline bool
    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
               const istreambuf_iterator<_CharT, _Traits>& __b)
    { return !__a.equal(__b); }

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:
      ostreambuf_iterator(ostream_type& __s) throw ()
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }

      ostreambuf_iterator(streambuf_type* __s) throw ()
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }

      ostreambuf_iterator&
      operator=(_CharT __c)
      {
        if (!_M_failed &&
            _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
          _M_failed = true;
        return *this;
      }

      ostreambuf_iterator&
      operator*() throw()
      { return *this; }

      ostreambuf_iterator&
      operator++(int) throw()
      { return *this; }

      ostreambuf_iterator&
      operator++() throw()
      { return *this; }

      bool
      failed() const throw()
      { return _M_failed; }

      ostreambuf_iterator&
      _M_put(const _CharT* __ws, streamsize __len)
      {
        if (__builtin_expect(!_M_failed, true) &&
            __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false))
          _M_failed = true;
        return *this;
      }
    };
}
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 2 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 3
#define _CPP_BITS_LOCFACETS_H 1

       
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwctype" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwctype" 3
#define _CPP_CWCTYPE 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 1 3 4
# 356 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef __need_wint_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#undef NULL

#define NULL __null
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 36 "/usr/include/wctype.h" 2 3 4
# 45 "/usr/include/wctype.h" 3 4



# 62 "/usr/include/wctype.h" 3 4
#define __iswxxx_defined 1




typedef unsigned long int wctype_t;

# 79 "/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 ();
# 186 "/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 ();


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



}
# 53 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwctype" 2 3
# 77 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cwctype" 3
namespace std
{
  using ::wint_t;

  using ::wctype_t;
  using ::wctrans_t;

  using ::iswalnum;
  using ::iswalpha;
  using ::iswblank;
  using ::iswcntrl;
  using ::iswdigit;
  using ::iswgraph;
  using ::iswlower;
  using ::iswprint;
  using ::iswprint;
  using ::iswpunct;
  using ::iswspace;
  using ::iswupper;
  using ::iswxdigit;
  using ::iswctype;
  using ::towlower;
  using ::towupper;
  using ::towctrans;
  using ::wctrans;
  using ::wctype;
}
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 2 3




namespace std
{


#define _GLIBCPP_NUM_FACETS 28







  template<typename _Tv>
    void
    __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
                   const __c_locale& __cloc, int __base = 10);


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

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


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

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


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

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

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



  template<typename _CharT, typename _Traits>
    struct __pad
    {
      static void
      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
             const _CharT* __olds, const streamsize __newlen,
             const streamsize __oldlen, const bool __num);
    };
# 125 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 3
  template<typename _CharT>
    bool
    __verify_grouping(const basic_string<_CharT>& __grouping,
                      basic_string<_CharT>& __grouping_tmp);






  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
                   const char* __gbeg, const char* __gend,
                   const _CharT* __first, const _CharT* __last);




  template<typename _CharT>
    inline
    ostreambuf_iterator<_CharT>
    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
    {
      __s._M_put(__ws, __len);
      return __s;
    }


  template<typename _CharT, typename _OutIter>
    inline
    _OutIter
    __write(_OutIter __s, const _CharT* __ws, int __len)
    {
      for (int __j = 0; __j < __len; __j++, ++__s)
        *__s = __ws[__j];
      return __s;
    }



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/ctype_base.h" 1 3
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/ctype_base.h" 3
  struct ctype_base
  {

    typedef const int* __to_type;



    typedef unsigned short mask;
    static const mask upper = _ISupper;
    static const mask lower = _ISlower;
    static const mask alpha = _ISalpha;
    static const mask digit = _ISdigit;
    static const mask xdigit = _ISxdigit;
    static const mask space = _ISspace;
    static const mask print = _ISprint;
    static const mask graph = _ISgraph;
    static const mask cntrl = _IScntrl;
    static const mask punct = _ISpunct;
    static const mask alnum = _ISalnum;
  };
# 167 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 2 3


  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:

      typedef _CharT char_type;

      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }

      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }

      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }

      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }

      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }

      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }

      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }

      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }

      char_type
      widen(char __c) const
      { return this->do_widen(__c); }

      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }

      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }

      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
              char __dfault, char *__to) const
      { return this->do_narrow(__lo, __hi, __dfault, __to); }

    protected:
      explicit
      __ctype_abstract_base(size_t __refs = 0): locale::facet(__refs) { }

      virtual
      ~__ctype_abstract_base() { }

      virtual bool
      do_is(mask __m, char_type __c) const = 0;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
            mask* __vec) const = 0;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
                 const char_type* __hi) const = 0;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const = 0;

      virtual char_type
      do_toupper(char_type) const = 0;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;

      virtual char_type
      do_tolower(char_type) const = 0;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;

      virtual char_type
      do_widen(char) const = 0;

      virtual const char*
      do_widen(const char* __lo, const char* __hi,
               char_type* __dest) const = 0;

      virtual char
      do_narrow(char_type, char __dfault) const = 0;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
                 char __dfault, char* __dest) const = 0;
    };


  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename ctype::mask mask;

      static locale::id id;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

   protected:
      virtual
      ~ctype();

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type __c) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type __c) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char __c) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
                char __dfault, char* __dest) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;


  template<>
    class ctype<char> : public __ctype_abstract_base<char>
    {
    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;

    public:
      static locale::id id;
      static const size_t table_size = 1 + static_cast<unsigned char>(-1);

      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);

      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
            size_t __refs = 0);

      inline bool
      is(mask __m, char __c) const;

      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;

      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;

      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;

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

      static const mask*
      classic_table() throw();

      virtual
      ~ctype();

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
                char __dfault, char* __dest) const;
    };

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



  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;

    public:

      static locale::id id;

      explicit
      ctype(size_t __refs = 0);

      explicit
      ctype(__c_locale __cloc, size_t __refs = 0);

    protected:
      __wmask_type
      _M_convert_to_wmask(const mask __m) const;

      virtual
      ~ctype();

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
                char __dfault, char* __dest) const;

    };

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



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/ctype_inline.h" 1 3
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/ctype_inline.h" 3
  bool
  ctype<char>::
  is(mask __m, char __c) const
  { return _M_table[static_cast<unsigned char>(__c)] & __m; }

  const char*
  ctype<char>::
  is(const char* __low, const char* __high, mask* __vec) const
  {
    while (__low < __high)
      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
    return __high;
  }

  const char*
  ctype<char>::
  scan_is(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
           && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
      ++__low;
    return __low;
  }

  const char*
  ctype<char>::
  scan_not(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
           && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
      ++__low;
    return __low;
  }
# 504 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 2 3


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

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

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


  template<>
    ctype_byname<char>::ctype_byname(const char*, size_t refs);

  template<>
    ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/codecvt.h" 1 3
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/codecvt.h" 3
#define _CPP_BITS_CODECVT_H 1

       
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/codecvt.h" 3


  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };





  template<typename _InternT, typename _ExternT, typename _StateT>
    class __codecvt_abstract_base
    : public locale::facet, public codecvt_base
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;


      result
      out(state_type& __state, const intern_type* __from,
          const intern_type* __from_end, const intern_type*& __from_next,
          extern_type* __to, extern_type* __to_end,
          extern_type*& __to_next) const
      {
        return this->do_out(__state, __from, __from_end, __from_next,
                            __to, __to_end, __to_next);
      }

      result
      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
              extern_type*& __to_next) const
      { return this->do_unshift(__state, __to,__to_end,__to_next); }

      result
      in(state_type& __state, const extern_type* __from,
         const extern_type* __from_end, const extern_type*& __from_next,
         intern_type* __to, intern_type* __to_end,
         intern_type*& __to_next) const
      {
        return this->do_in(__state, __from, __from_end, __from_next,
                           __to, __to_end, __to_next);
      }

      int
      encoding() const throw()
      { return this->do_encoding(); }

      bool
      always_noconv() const throw()
      { return this->do_always_noconv(); }

      int
      length(const state_type& __state, const extern_type* __from,
             const extern_type* __end, size_t __max) const
      { return this->do_length(__state, __from, __end, __max); }

      int
      max_length() const throw()
      { return this->do_max_length(); }

    protected:
      explicit
      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~__codecvt_abstract_base() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const = 0;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const = 0;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
            const extern_type* __from_end, const extern_type*& __from_next,
            intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const = 0;

      virtual int
      do_encoding() const throw() = 0;

      virtual bool
      do_always_noconv() const throw() = 0;

      virtual int
      do_length(const 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;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }

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

    public:
      static locale::id id;

      explicit
      codecvt(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(const 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;

    public:
      static locale::id id;

      explicit
      codecvt(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(const 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*, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/codecvt_specializations.h" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/codecvt_specializations.h" 3
#define _GLIBCPP_USE___ENC_TRAITS 1





  class __enc_traits
  {
  public:



    typedef iconv_t __desc_type;

  protected:


    static const int _S_max_size = 32;

    char _M_int_enc[_S_max_size];

    char _M_ext_enc[_S_max_size];


    __desc_type _M_in_desc;

    __desc_type _M_out_desc;


    int _M_ext_bom;


    int _M_int_bom;

  public:
    explicit __enc_traits()
    : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0)
    {
      memset(_M_int_enc, 0, _S_max_size);
      memset(_M_ext_enc, 0, _S_max_size);
    }

    explicit __enc_traits(const char* __int, const char* __ext,
                          int __ibom = 0, int __ebom = 0)
    : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0)
    {
      strncpy(_M_int_enc, __int, _S_max_size);
      strncpy(_M_ext_enc, __ext, _S_max_size);
    }






    __enc_traits(const __enc_traits& __obj): _M_in_desc(0), _M_out_desc(0)
    {
      strncpy(_M_int_enc, __obj._M_int_enc, _S_max_size);
      strncpy(_M_ext_enc, __obj._M_ext_enc, _S_max_size);
      _M_ext_bom = __obj._M_ext_bom;
      _M_int_bom = __obj._M_int_bom;
    }


    __enc_traits&
    operator=(const __enc_traits& __obj)
    {
      strncpy(_M_int_enc, __obj._M_int_enc, _S_max_size);
      strncpy(_M_ext_enc, __obj._M_ext_enc, _S_max_size);
      _M_in_desc = 0;
      _M_out_desc = 0;
      _M_ext_bom = __obj._M_ext_bom;
      _M_int_bom = __obj._M_int_bom;
      return *this;
    }

    ~__enc_traits()
    {
      __desc_type __err = reinterpret_cast<iconv_t>(-1);
      if (_M_in_desc && _M_in_desc != __err)
        iconv_close(_M_in_desc);
      if (_M_out_desc && _M_out_desc != __err)
        iconv_close(_M_out_desc);
    }

    void
    _M_init()
    {
      const __desc_type __err = reinterpret_cast<iconv_t>(-1);
      if (!_M_in_desc)
        {
          _M_in_desc = iconv_open(_M_int_enc, _M_ext_enc);
          if (_M_in_desc == __err)
            __throw_runtime_error("creating iconv input descriptor failed.");
        }
      if (!_M_out_desc)
        {
          _M_out_desc = iconv_open(_M_ext_enc, _M_int_enc);
          if (_M_out_desc == __err)
            __throw_runtime_error("creating iconv output descriptor failed.");
        }
    }

    bool
    _M_good()
    {
      const __desc_type __err = reinterpret_cast<iconv_t>(-1);
      bool __test = _M_in_desc && _M_in_desc != __err;
      __test &= _M_out_desc && _M_out_desc != __err;
      return __test;
    }

    const __desc_type*
    _M_get_in_descriptor()
    { return &_M_in_desc; }

    const __desc_type*
    _M_get_out_descriptor()
    { return &_M_out_desc; }

    int
    _M_get_external_bom()
    { return _M_ext_bom; }

    int
    _M_get_internal_bom()
    { return _M_int_bom; }

    const char*
    _M_get_internal_enc()
    { return _M_int_enc; }

    const char*
    _M_get_external_enc()
    { return _M_ext_enc; }
  };




  template<typename _InternT, typename _ExternT>
    class codecvt<_InternT, _ExternT, __enc_traits>
    : public __codecvt_abstract_base<_InternT, _ExternT, __enc_traits>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef __enc_traits state_type;
      typedef __enc_traits::__desc_type __desc_type;
      typedef __enc_traits __enc_type;


      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
      { }

      explicit
      codecvt(__enc_type* __enc, size_t __refs = 0)
      : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
      { }

    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(const 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>
    locale::id
    codecvt<_InternT, _ExternT, __enc_traits>::id;





  template<typename _T>
    inline size_t
    __iconv_adaptor(size_t(*__func)(iconv_t, _T, size_t*, char**, size_t*),
                    iconv_t __cd, char** __inbuf, size_t* __inbytes,
                    char** __outbuf, size_t* __outbytes)
    { return __func(__cd, (_T)__inbuf, __inbytes, __outbuf, __outbytes); }

  template<typename _InternT, typename _ExternT>
    codecvt_base::result
    codecvt<_InternT, _ExternT, __enc_traits>::
    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
    {
      result __ret = codecvt_base::error;
      if (__state._M_good())
        {
          typedef state_type::__desc_type __desc_type;
          const __desc_type* __desc = __state._M_get_out_descriptor();
          const size_t __fmultiple = sizeof(intern_type);
          size_t __fbytes = __fmultiple * (__from_end - __from);
          const size_t __tmultiple = sizeof(extern_type);
          size_t __tbytes = __tmultiple * (__to_end - __to);



          char* __cto = reinterpret_cast<char*>(__to);
          char* __cfrom;
          size_t __conv;






          int __int_bom = __state._M_get_internal_bom();
          if (__int_bom)
            {
              size_t __size = __from_end - __from;
              intern_type* __cfixed = static_cast<intern_type*>(__builtin_alloca(sizeof(intern_type) * (__size + 1)));
              __cfixed[0] = static_cast<intern_type>(__int_bom);
              char_traits<intern_type>::copy(__cfixed + 1, __from, __size);
              __cfrom = reinterpret_cast<char*>(__cfixed);
              __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
                                        &__fbytes, &__cto, &__tbytes);
            }
          else
            {
              intern_type* __cfixed = const_cast<intern_type*>(__from);
              __cfrom = reinterpret_cast<char*>(__cfixed);
              __conv = __iconv_adaptor(iconv, *__desc, &__cfrom, &__fbytes,
                                       &__cto, &__tbytes);
            }

          if (__conv != size_t(-1))
            {
              __from_next = reinterpret_cast<const intern_type*>(__cfrom);
              __to_next = reinterpret_cast<extern_type*>(__cto);
              __ret = codecvt_base::ok;
            }
          else
            {
              if (__fbytes < __fmultiple * (__from_end - __from))
                {
                  __from_next = reinterpret_cast<const intern_type*>(__cfrom);
                  __to_next = reinterpret_cast<extern_type*>(__cto);
                  __ret = codecvt_base::partial;
                }
              else
                __ret = codecvt_base::error;
            }
        }
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    codecvt_base::result
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_unshift(state_type& __state, extern_type* __to,
               extern_type* __to_end, extern_type*& __to_next) const
    {
      result __ret = codecvt_base::error;
      if (__state._M_good())
        {
          typedef state_type::__desc_type __desc_type;
          const __desc_type* __desc = __state._M_get_in_descriptor();
          const size_t __tmultiple = sizeof(intern_type);
          size_t __tlen = __tmultiple * (__to_end - __to);



          char* __cto = reinterpret_cast<char*>(__to);
          size_t __conv = __iconv_adaptor(iconv,*__desc, __null, __null,
                                          &__cto, &__tlen);

          if (__conv != size_t(-1))
            {
              __to_next = reinterpret_cast<extern_type*>(__cto);
              if (__tlen == __tmultiple * (__to_end - __to))
                __ret = codecvt_base::noconv;
              else if (__tlen == 0)
                __ret = codecvt_base::ok;
              else
                __ret = codecvt_base::partial;
            }
          else
            __ret = codecvt_base::error;
        }
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    codecvt_base::result
    codecvt<_InternT, _ExternT, __enc_traits>::
    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
    {
      result __ret = codecvt_base::error;
      if (__state._M_good())
        {
          typedef state_type::__desc_type __desc_type;
          const __desc_type* __desc = __state._M_get_in_descriptor();
          const size_t __fmultiple = sizeof(extern_type);
          size_t __flen = __fmultiple * (__from_end - __from);
          const size_t __tmultiple = sizeof(intern_type);
          size_t __tlen = __tmultiple * (__to_end - __to);



          char* __cto = reinterpret_cast<char*>(__to);
          char* __cfrom;
          size_t __conv;






          int __ext_bom = __state._M_get_external_bom();
          if (__ext_bom)
            {
              size_t __size = __from_end - __from;
              extern_type* __cfixed = static_cast<extern_type*>(__builtin_alloca(sizeof(extern_type) * (__size + 1)));
              __cfixed[0] = static_cast<extern_type>(__ext_bom);
              char_traits<extern_type>::copy(__cfixed + 1, __from, __size);
              __cfrom = reinterpret_cast<char*>(__cfixed);
              __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
                                       &__flen, &__cto, &__tlen);
            }
          else
            {
              extern_type* __cfixed = const_cast<extern_type*>(__from);
              __cfrom = reinterpret_cast<char*>(__cfixed);
              __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
                                       &__flen, &__cto, &__tlen);
            }


          if (__conv != size_t(-1))
            {
              __from_next = reinterpret_cast<const extern_type*>(__cfrom);
              __to_next = reinterpret_cast<intern_type*>(__cto);
              __ret = codecvt_base::ok;
            }
          else
            {
              if (__flen < static_cast<size_t>(__from_end - __from))
                {
                  __from_next = reinterpret_cast<const extern_type*>(__cfrom);
                  __to_next = reinterpret_cast<intern_type*>(__cto);
                  __ret = codecvt_base::partial;
                }
              else
                __ret = codecvt_base::error;
            }
        }
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    int
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_encoding() const throw()
    {
      int __ret = 0;
      if (sizeof(_ExternT) <= sizeof(_InternT))
        __ret = sizeof(_InternT)/sizeof(_ExternT);
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    bool
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_always_noconv() const throw()
    { return false; }

  template<typename _InternT, typename _ExternT>
    int
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_length(const state_type&, const extern_type* __from,
              const extern_type* __end, size_t __max) const
    { return min(__max, static_cast<size_t>(__end - __from)); }



  template<typename _InternT, typename _ExternT>
    int
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_max_length() const throw()
    { return 1; }
# 335 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/codecvt.h" 2 3
# 529 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 2 3


  class __num_base
  {
  public:


    enum
      {
        _S_minus,
        _S_plus,
        _S_x,
        _S_X,
        _S_digits,
        _S_digits_end = _S_digits + 16,
        _S_udigits = _S_digits_end,
        _S_udigits_end = _S_udigits + 16,
        _S_e = _S_digits + 14,
        _S_E = _S_udigits + 14,
        _S_end = _S_udigits_end
      };






    static const char* _S_atoms_out;

  protected:


    static const char* _S_atoms_in;

    enum
    {
      _M_zero,
      _M_e = _M_zero + 10,
      _M_E = _M_zero + 11,
      _M_size = 21 + 1
    };



    static void
    _S_format_float(const ios_base& __io, char* __fptr, char __mod,
                    streamsize __prec);


    static void
    _S_format_int(const ios_base& __io, char* __fptr, char __mod, char __modl);
  };


  template<typename _CharT>
    class __locale_cache;

  template<typename _CharT>
    class numpunct : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      friend class __locale_cache<numpunct<_CharT> >;

      static locale::id id;

    private:
      char_type _M_decimal_point;
      char_type _M_thousands_sep;
      const char* _M_grouping;
      const char_type* _M_truename;
      const char_type* _M_falsename;

    public:
      explicit
      numpunct(size_t __refs = 0) : locale::facet(__refs)
      { _M_initialize_numpunct(); }

      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0) : locale::facet(__refs)
      { _M_initialize_numpunct(__cloc); }

      char_type
      decimal_point() const
      { return this->do_decimal_point(); }

      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }

      string
      grouping() const
      { return this->do_grouping(); }

      string_type
      truename() const
      { return this->do_truename(); }

      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:
      virtual
      ~numpunct();

      virtual char_type
      do_decimal_point() const
      { return _M_decimal_point; }

      virtual char_type
      do_thousands_sep() const
      { return _M_thousands_sep; }

      virtual string
      do_grouping() const
      { return _M_grouping; }

      virtual string_type
      do_truename() const
      { return _M_truename; }

      virtual string_type
      do_falsename() const
      { return _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>
    {

      __c_locale _M_c_locale_numpunct;

    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      numpunct_byname(const char* __s, size_t __refs = 0)
      : numpunct<_CharT>(__refs)
      {
        _S_create_c_locale(_M_c_locale_numpunct, __s);
        _M_initialize_numpunct(_M_c_locale_numpunct);
      }

    protected:
      virtual
      ~numpunct_byname()
      { _S_destroy_c_locale(_M_c_locale_numpunct); }
    };

  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet, public __num_base
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      static locale::id id;

      explicit
      num_get(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, bool& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned short& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned int& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, float& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, long double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, void*& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

    protected:
      virtual ~num_get() { }

      iter_type
      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
                       string& __xtrc) const;

      iter_type
      _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
                     string& __xtrc, int& __base) const;

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


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

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
              unsigned short&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             unsigned int&) const;

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


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

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


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

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

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

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             void*&) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 853 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet, public __num_base
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;
      static locale::id id;

      explicit
      num_put(size_t __refs = 0) : locale::facet(__refs) { }

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

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

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


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

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


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

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

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

    protected:
      template<typename _ValueT>
        iter_type
        _M_convert_float(iter_type, ios_base& __io, char_type __fill,
                         char __mod, _ValueT __v) const;

      void
      _M_group_float(const string& __grouping, char_type __sep,
                     const char_type* __p, char_type* __new, char_type* __cs,
                     int& __len) const;

      template<typename _ValueT>
        iter_type
        _M_convert_int(iter_type, ios_base& __io, char_type __fill,
                       _ValueT __v) const;

      void
      _M_group_int(const string& __grouping, 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;



      template<typename _ValueT>
        iter_type
        _M_convert_int(iter_type, ios_base& __io, char_type __fill,
                       char __mod, char __modl, _ValueT __v) const;

      iter_type
      _M_widen_float(iter_type, ios_base& __io, char_type __fill, char* __cs,
                     int __len) const;

      iter_type
      _M_widen_int(iter_type, ios_base& __io, char_type __fill, char* __cs,
                   int __len) const;

      iter_type
      _M_insert(iter_type, ios_base& __io, char_type __fill,
                const char_type* __ws, int __len) const;


     virtual
      ~num_put() { };

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, bool __v) const;

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

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


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

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


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

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

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;


  template<typename _CharT>
    class collate : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

    protected:


      __c_locale _M_c_locale_collate;

    public:
      static locale::id id;

      explicit
      collate(size_t __refs = 0)
      : locale::facet(__refs)
      { _M_c_locale_collate = _S_c_locale; }

      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : locale::facet(__refs)
      { _M_c_locale_collate = _S_clone_c_locale(__cloc); }

      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
              const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }

      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }

      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_hash(__lo, __hi); }


      int
      _M_compare(const _CharT*, const _CharT*) const;

      size_t
      _M_transform(_CharT*, const _CharT*, size_t) const;

  protected:
      virtual
      ~collate()
      { _S_destroy_c_locale(_M_c_locale_collate); }

      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
                 const _CharT* __lo2, const _CharT* __hi2) const;

      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;

      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const;
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;


  template<>
    int
    collate<char>::_M_compare(const char*, const char*) const;

  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)
      {
        _S_destroy_c_locale(_M_c_locale_collate);
        _S_create_c_locale(_M_c_locale_collate, __s);
      }

    protected:
      virtual
      ~collate_byname() { }
    };


  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT>
    class __timepunct : public locale::facet
    {
    public:

      typedef _CharT __char_type;
      typedef basic_string<_CharT> __string_type;

      static locale::id id;


      static const _CharT* _S_timezones[14];

    protected:
      __c_locale _M_c_locale_timepunct;
      char* _M_name_timepunct;
      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_day_a1;
      const _CharT* _M_day_a2;
      const _CharT* _M_day_a3;
      const _CharT* _M_day_a4;
      const _CharT* _M_day_a5;
      const _CharT* _M_day_a6;
      const _CharT* _M_day_a7;


      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_month_a01;
      const _CharT* _M_month_a02;
      const _CharT* _M_month_a03;
      const _CharT* _M_month_a04;
      const _CharT* _M_month_a05;
      const _CharT* _M_month_a06;
      const _CharT* _M_month_a07;
      const _CharT* _M_month_a08;
      const _CharT* _M_month_a09;
      const _CharT* _M_month_a10;
      const _CharT* _M_month_a11;
      const _CharT* _M_month_a12;

    public:
      explicit
      __timepunct(size_t __refs = 0);

      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);

      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
             const tm* __tm) const;

      void
      _M_date_formats(const _CharT** __date) const
      {

        __date[0] = _M_date_format;
        __date[1] = _M_date_era_format;
      }

      void
      _M_time_formats(const _CharT** __time) const
      {

        __time[0] = _M_time_format;
        __time[1] = _M_time_era_format;
      }

      void
      _M_ampm(const _CharT** __ampm) const
      {
        __ampm[0] = _M_am;
        __ampm[1] = _M_pm;
      }

      void
      _M_date_time_formats(const _CharT** __dt) const
      {

        __dt[0] = _M_date_time_format;
        __dt[1] = _M_date_time_era_format;
      }

      void
      _M_days(const _CharT** __days) const
      {
        __days[0] = _M_day1;
        __days[1] = _M_day2;
        __days[2] = _M_day3;
        __days[3] = _M_day4;
        __days[4] = _M_day5;
        __days[5] = _M_day6;
        __days[6] = _M_day7;
      }

      void
      _M_days_abbreviated(const _CharT** __days) const
      {
        __days[0] = _M_day_a1;
        __days[1] = _M_day_a2;
        __days[2] = _M_day_a3;
        __days[3] = _M_day_a4;
        __days[4] = _M_day_a5;
        __days[5] = _M_day_a6;
        __days[6] = _M_day_a7;
      }

      void
      _M_months(const _CharT** __months) const
      {
        __months[0] = _M_month01;
        __months[1] = _M_month02;
        __months[2] = _M_month03;
        __months[3] = _M_month04;
        __months[4] = _M_month05;
        __months[5] = _M_month06;
        __months[6] = _M_month07;
        __months[7] = _M_month08;
        __months[8] = _M_month09;
        __months[9] = _M_month10;
        __months[10] = _M_month11;
        __months[11] = _M_month12;
      }

      void
      _M_months_abbreviated(const _CharT** __months) const
      {
        __months[0] = _M_month_a01;
        __months[1] = _M_month_a02;
        __months[2] = _M_month_a03;
        __months[3] = _M_month_a04;
        __months[4] = _M_month_a05;
        __months[5] = _M_month_a06;
        __months[6] = _M_month_a07;
        __months[7] = _M_month_a08;
        __months[8] = _M_month_a09;
        __months[9] = _M_month_a10;
        __months[10] = _M_month_a11;
        __months[11] = _M_month_a12;
      }

    protected:
      virtual
      ~__timepunct();


      void
      _M_initialize_timepunct(__c_locale __cloc = __null);
    };

  template<typename _CharT>
    locale::id __timepunct<_CharT>::id;


  template<>
    const char*
    __timepunct<char>::_S_timezones[14];

  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<>
    const wchar_t*
    __timepunct<wchar_t>::_S_timezones[14];

  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;



  template<typename _CharT>
    const _CharT* __timepunct<_CharT>::_S_timezones[14];


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/time_members.h" 1 3
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/time_members.h" 3
  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(size_t __refs)
    : locale::facet(__refs)
    {



      _M_initialize_timepunct();
    }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__c_locale __cloc,
                                     const char* __s,
                                     size_t __refs)
    : locale::facet(__refs)
    {




      _M_initialize_timepunct(__cloc);
    }

  template<typename _CharT>
    __timepunct<_CharT>::~__timepunct()
    {




      _S_destroy_c_locale(_M_c_locale_timepunct);
    }
# 1311 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 2 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;

      explicit
      time_get(size_t __refs = 0)
      : locale::facet (__refs) { }

      dateorder
      date_order() const
      { return this->do_date_order(); }

      iter_type
      get_time(iter_type __beg, iter_type __end, ios_base& __io,
               ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_time(__beg, __end, __io, __err, __tm); }

      iter_type
      get_date(iter_type __beg, iter_type __end, ios_base& __io,
               ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_date(__beg, __end, __io, __err, __tm); }

      iter_type
      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
                  ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }

      iter_type
      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
                    ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }

      iter_type
      get_year(iter_type __beg, iter_type __end, ios_base& __io,
               ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_year(__beg, __end, __io, __err, __tm); }

    protected:
      virtual
      ~time_get() { }

      virtual dateorder
      do_date_order() const;

      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
                  ios_base::iostate& __err, tm* __tm) const;

      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
                  ios_base::iostate& __err, tm* __tm) const;

      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
                     ios_base::iostate& __err, tm* __tm) const;

      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
                       ios_base::iostate& __err, tm* __tm) const;

      virtual iter_type
      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
                  ios_base::iostate& __err, tm* __tm) const;


      void
      _M_extract_num(iter_type& __beg, iter_type& __end, int& __member,
                     int __min, int __max, size_t __len,
                     const ctype<_CharT>& __ctype,
                     ios_base::iostate& __err) const;



      void
      _M_extract_name(iter_type& __beg, iter_type& __end, int& __member,
                      const _CharT** __names, size_t __indexlen,
                      ios_base::iostate& __err) const;


      void
      _M_extract_via_format(iter_type& __beg, iter_type& __end, ios_base& __io,
                            ios_base::iostate& __err, tm* __tm,
                            const _CharT* __format) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;

  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }

    protected:
      virtual
      ~time_get_byname() { }
    };

  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet, public time_base
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      static locale::id id;

      explicit
      time_put(size_t __refs = 0)
      : locale::facet(__refs) { }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
          const _CharT* __beg, const _CharT* __end) const;

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
          const tm* __tm, char __format, char __mod = 0) const
      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }

    protected:
      virtual
      ~time_put()
      { }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
             char __format, char __mod) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;

  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char* , size_t __refs = 0)
      : time_put<_CharT, _OutIter>(__refs)
      { };

    protected:
      virtual
      ~time_put_byname() { }
    };


  class money_base
  {
  public:
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;



    static pattern
    _S_construct_pattern(char __precedes, char __space, char __posn);
  };

  template<typename _CharT, bool _Intl>
    class moneypunct : public locale::facet, public money_base
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;
      static locale::id id;

    private:
      const char* _M_grouping;
      char_type _M_decimal_point;
      char_type _M_thousands_sep;
      const char_type* _M_curr_symbol;
      const char_type* _M_positive_sign;
      const char_type* _M_negative_sign;
      int _M_frac_digits;
      pattern _M_pos_format;
      pattern _M_neg_format;

    public:
      explicit
      moneypunct(size_t __refs = 0) : locale::facet(__refs)
      { _M_initialize_moneypunct(); }

      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : locale::facet(__refs)
      { _M_initialize_moneypunct(__cloc, __s); }

      char_type
      decimal_point() const
      { return this->do_decimal_point(); }

      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }

      string
      grouping() const
      { return this->do_grouping(); }

      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }

      string_type
      positive_sign() const
      { return this->do_positive_sign(); }

      string_type
      negative_sign() const
      { return this->do_negative_sign(); }

      int
      frac_digits() const
      { return this->do_frac_digits(); }

      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }

    protected:
      virtual
      ~moneypunct();

      virtual char_type
      do_decimal_point() const
      { return _M_decimal_point; }

      virtual char_type
      do_thousands_sep() const
      { return _M_thousands_sep; }

      virtual string
      do_grouping() const
      { return _M_grouping; }

      virtual string_type
      do_curr_symbol() const
      { return _M_curr_symbol; }

      virtual string_type
      do_positive_sign() const
      { return _M_positive_sign; }

      virtual string_type
      do_negative_sign() const
      { return _M_negative_sign; }

      virtual int
      do_frac_digits() const
      { return _M_frac_digits; }

      virtual pattern
      do_pos_format() const
      { return _M_pos_format; }

      virtual pattern
      do_neg_format() const
      { return _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>
    {
      __c_locale _M_c_locale_moneypunct;

    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)
      {
        _S_create_c_locale(_M_c_locale_moneypunct, __s);
        _M_initialize_moneypunct(_M_c_locale_moneypunct);
      }

    protected:
      virtual
      ~moneypunct_byname()
      { _S_destroy_c_locale(_M_c_locale_moneypunct); }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;

  template<typename _CharT, typename _InIter>
    class money_get : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      money_get(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
          ios_base::iostate& __err, long double& __units) const
      { return this->do_get(__s, __end, __intl, __io, __err, __units); }

      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
          ios_base::iostate& __err, string_type& __digits) const
      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }

    protected:
      virtual
      ~money_get() { }

      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
             ios_base::iostate& __err, long double& __units) const;

      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
             ios_base::iostate& __err, string_type& __digits) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;

  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      money_put(size_t __refs = 0) : locale::facet(__refs) { }

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

      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
          char_type __fill, const string_type& __digits) const
      { return this->do_put(__s, __intl, __io, __fill, __digits); }

    protected:
      virtual
      ~money_put() { }

      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
             long double __units) const;

      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
             const string_type& __digits) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;


  struct messages_base
  {
    typedef int catalog;
  };

  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

    protected:


      __c_locale _M_c_locale_messages;
      char* _M_name_messages;

    public:
      static locale::id id;

      explicit
      messages(size_t __refs = 0);


      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);

      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }


      catalog
      open(const basic_string<char>&, const locale&, const char*) const;

      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }

      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:
      virtual
      ~messages();

      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;

      virtual string_type
      do_get(catalog, int, int, const string_type& __dfault) const;

      virtual void
      do_close(catalog) const;


      char*
      _M_convert_to_char(const string_type& __msg) const
      {

        return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
      }


      string_type
      _M_convert_from_char(char* __msg) const
      {

        size_t __len = char_traits<char>::length(__msg) - 1;
# 1856 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 3
        return string_type();
      }
     };

  template<typename _CharT>
    locale::id messages<_CharT>::id;


  template<>
    string
    messages<char>::do_get(catalog, int, int, const string&) const;


  template<>
    wstring
    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;


  template<typename _CharT>
    class messages_byname : public messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

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

    protected:
      virtual
      ~messages_byname()
      { }
    };


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/messages_members.h" 1 3
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/i686-pc-linux-gnu/bits/messages_members.h" 3
  template<typename _CharT>
     messages<_CharT>::messages(size_t __refs)
     : locale::facet(__refs)
     {



       _M_c_locale_messages = _S_c_locale;
     }

  template<typename _CharT>
     messages<_CharT>::messages(__c_locale __cloc,
                                const char* __s, size_t __refs)
     : locale::facet(__refs)
     {




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




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






       _S_destroy_c_locale(_M_c_locale_messages);
       _S_create_c_locale(_M_c_locale_messages, __s);
     }
# 1892 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 2 3






  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }

  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }

  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }

  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }

  template<typename _CharT>
    inline bool islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }

  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }

  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }

  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }

  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }

  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }

  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }

  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }

  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
# 1973 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 3
  class __locale_cache_base
  {
    friend class std::locale::_Impl;
    friend class locale;

  public:
    virtual
    ~__locale_cache_base() { }

  };



  template<typename _Facet>
    class __locale_cache : public __locale_cache_base
    {

      __locale_cache(const locale&) {}
    };

  template<typename _CharT>
    class __locale_cache<numpunct<_CharT> > : public __locale_cache_base
    {

      typedef _CharT char_type;
      typedef char_traits<_CharT> traits_type;
      typedef basic_string<_CharT> string_type;

    public:





      _CharT _M_decimal_point;





      _CharT _M_thousands_sep;



      const _CharT* _M_truename;
      const _CharT* _M_falsename;



      bool _M_use_grouping;



      const char* _M_grouping;
# 2035 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.h" 3
      _CharT _M_atoms_out[__num_base::_S_end];


      __locale_cache(const locale& __loc);
      __locale_cache(const locale& __loc, bool);

      ~__locale_cache()
      {
        delete [] _M_truename;
        delete [] _M_falsename;
        delete [] _M_grouping;
      }
    };
}
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 2 3

namespace std
{







  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {
    public:






      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;
# 78 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      typedef ctype<_CharT> __ctype_type;
      typedef ostreambuf_iterator<_CharT, _Traits> __ostreambuf_iter;
      typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
      typedef istreambuf_iterator<_CharT, _Traits> __istreambuf_iter;
      typedef num_get<_CharT, __istreambuf_iter> __numget_type;


      friend void ios_base::Init::_S_ios_create(bool);


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

      const __numput_type* _M_fnumput;

      const __numget_type* _M_fnumget;

    public:







      operator void*() const
      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }

      bool
      operator!() const
      { return this->fail(); }
# 124 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 135 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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; }
# 188 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 209 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 244 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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_fctype(0), _M_fnumput(0), _M_fnumget(0)
      { this->init(__sb); }







      virtual
      ~basic_ios() { }
# 281 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 293 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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; }
# 326 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);




      basic_ios&
      copyfmt(const basic_ios& __rhs);







      char_type
      fill() const
      {
        if (!_M_fill_init)
          {
            _M_fill = this->widen(' ');
            _M_fill_init = true;
          }
        return _M_fill;
      }
# 361 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
        char_type __old = this->fill();
        _M_fill = __ch;
        return __old;
      }
# 381 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 401 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const;
# 419 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      char_type
      widen(char __c) const;

    protected:







      basic_ios() : ios_base()
      { }
# 441 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 3
      void
      init(basic_streambuf<_CharT, _Traits>* __sb);

      bool
      _M_check_facet(const locale::facet* __f) const
      {
        if (!__f)
          __throw_bad_cast();
        return true;
      }

      void
      _M_cache_locale(const locale& __loc);



      void
      _M_cache_facets(const locale& __loc);

    };
}


#define export 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.tcc" 1 3
# 31 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.tcc" 3
#define _CPP_BITS_BASICIOS_TCC 1

       
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.tcc" 3

namespace std
{
  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::clear(iostate __state)
    {
      if (this->rdbuf())
        _M_streambuf_state = __state;
      else
          _M_streambuf_state = __state | badbit;
      if ((this->rdstate() & this->exceptions()))
        __throw_ios_failure("basic_ios::clear(iostate) caused exception");
    }

  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];
          if (_M_word != _M_local_word)
            {
              delete [] _M_word;
              _M_word = 0;
            }
          _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_call_callbacks(copyfmt_event);

          _M_cache_locale(_M_ios_locale);



          this->exceptions(__rhs.exceptions());
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    char
    basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
    {
      char __ret = __dfault;
      if (_M_check_facet(_M_fctype))
        __ret = _M_fctype->narrow(__c, __dfault);
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    _CharT
    basic_ios<_CharT, _Traits>::widen(char __c) const
    {
      char_type __ret = char_type();
      if (_M_check_facet(_M_fctype))
        __ret = _M_fctype->widen(__c);
      return __ret;
    }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_locale(__loc);
      if (this->rdbuf() != 0)
        this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();
      _M_cache_locale(_M_ios_locale);
      _M_tie = 0;
# 170 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.tcc" 3
      _M_fill = _CharT();
      _M_fill_init = false;

      _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_fctype = &use_facet<__ctype_type>(__loc);
      else
        _M_fctype = 0;
      if (__builtin_expect(has_facet<__numput_type>(__loc), true))
        _M_fnumput = &use_facet<__numput_type>(__loc);
      else
        _M_fnumput = 0;
      if (__builtin_expect(has_facet<__numget_type>(__loc), true))
        _M_fnumget = &use_facet<__numget_type>(__loc);
      else
        _M_fnumget = 0;
    }



  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::_M_cache_facets(const locale& __loc)
    {
      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
        _M_fctype = &use_facet<__ctype_type>(__loc);
      if (__builtin_expect(has_facet<__numput_type>(__loc), true))
        _M_fnumput = &use_facet<__numput_type>(__loc);
      if (__builtin_expect(has_facet<__numget_type>(__loc), true))
        _M_fnumget = &use_facet<__numget_type>(__loc);
    }






  extern template class basic_ios<char>;


  extern template class basic_ios<wchar_t>;


}
# 466 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/basic_ios.h" 2 3
# 52 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ios" 2 3
# 46 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 2 3

namespace std
{
# 57 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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 ostreambuf_iterator<_CharT, _Traits> __ostreambuf_iter;
      typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
      typedef ctype<_CharT> __ctype_type;

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2);

      template<typename _Traits2>
        friend basic_ostream<char, _Traits2>&
        operator<<(basic_ostream<char, _Traits2>&, char);

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*);

      template<typename _Traits2>
        friend basic_ostream<char, _Traits2>&
        operator<<(basic_ostream<char, _Traits2>&, const char*);

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, const char*);
# 104 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 130 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&));

      __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&));

      __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&));
# 167 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      __ostream_type&
      operator<<(long __n);

      __ostream_type&
      operator<<(unsigned long __n);

      __ostream_type&
      operator<<(bool __n);

      __ostream_type&
      operator<<(short __n)
      {
        ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
        if (__fmt & ios_base::oct || __fmt & ios_base::hex)
          return this->operator<<(static_cast<unsigned long>
                                  (static_cast<unsigned short>(__n)));
        else
          return this->operator<<(static_cast<long>(__n));
      }

      __ostream_type&
      operator<<(unsigned short __n)
      { return this->operator<<(static_cast<unsigned long>(__n)); }

      __ostream_type&
      operator<<(int __n)
      {
        ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
        if (__fmt & ios_base::oct || __fmt & ios_base::hex)
          return this->operator<<(static_cast<unsigned long>
                                  (static_cast<unsigned int>(__n)));
        else
          return this->operator<<(static_cast<long>(__n));
      }

      __ostream_type&
      operator<<(unsigned int __n)
      { return this->operator<<(static_cast<unsigned long>(__n)); }


      __ostream_type&
      operator<<(long long __n);

      __ostream_type&
      operator<<(unsigned long long __n);


      __ostream_type&
      operator<<(double __f);

      __ostream_type&
      operator<<(float __f)
      { return this->operator<<(static_cast<double>(__f)); }

      __ostream_type&
      operator<<(long double __f);

      __ostream_type&
      operator<<(const void* __p);
# 248 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 281 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      __ostream_type&
      put(char_type __c);
# 300 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 313 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      __ostream_type&
      flush();
# 324 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      pos_type
      tellp();
# 335 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 347 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);
    };
# 361 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

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

    public:
# 380 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      explicit
      sentry(basic_ostream<_CharT,_Traits>& __os);
# 390 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      ~sentry()
      {

        if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
          {

            if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
              _M_os.setstate(ios_base::badbit);
          }
      }
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
      operator bool()
      { return _M_ok; }
    };
# 429 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }
# 469 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<class _Traits>
    basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }
# 503 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }







  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_CharT()); }






  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }

}


#define export 


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ostream.tcc" 1 3
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ostream.tcc" 3
       
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ostream.tcc" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/locale" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/locale" 3
#define _CPP_LOCALE 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/locale" 3




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 1 3
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 3
#define _CPP_BITS_LOCFACETS_TCC 1

       
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cerrno" 1 3
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cerrno" 3
#define _CPP_CERRNO 1

       
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cerrno" 3

# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
#define _ERRNO_H 1



extern "C" {



# 1 "/usr/include/bits/errno.h" 1 3 4
# 25 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4

#define _LINUX_ERRNO_H 

# 1 "/usr/include/asm/errno.h" 1 3 4

#define _I386_ERRNO_H 

# 1 "/usr/include/asm-generic/errno.h" 1 3 4

#define _ASM_GENERIC_ERRNO_H 

# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4

#define _ASM_GENERIC_ERRNO_BASE_H 

#define EPERM 1
#define ENOENT 2
#define ESRCH 3
#define EINTR 4
#define EIO 5
#define ENXIO 6
#define E2BIG 7
#define ENOEXEC 8
#define EBADF 9
#define ECHILD 10
#define EAGAIN 11
#define ENOMEM 12
#define EACCES 13
#define EFAULT 14
#define ENOTBLK 15
#define EBUSY 16
#define EEXIST 17
#define EXDEV 18
#define ENODEV 19
#define ENOTDIR 20
#define EISDIR 21
#define EINVAL 22
#define ENFILE 23
#define EMFILE 24
#define ENOTTY 25
#define ETXTBSY 26
#define EFBIG 27
#define ENOSPC 28
#define ESPIPE 29
#define EROFS 30
#define EMLINK 31
#define EPIPE 32
#define EDOM 33
#define ERANGE 34
# 5 "/usr/include/asm-generic/errno.h" 2 3 4

#define EDEADLK 35
#define ENAMETOOLONG 36
#define ENOLCK 37
#define ENOSYS 38
#define ENOTEMPTY 39
#define ELOOP 40
#define EWOULDBLOCK EAGAIN
#define ENOMSG 42
#define EIDRM 43
#define ECHRNG 44
#define EL2NSYNC 45
#define EL3HLT 46
#define EL3RST 47
#define ELNRNG 48
#define EUNATCH 49
#define ENOCSI 50
#define EL2HLT 51
#define EBADE 52
#define EBADR 53
#define EXFULL 54
#define ENOANO 55
#define EBADRQC 56
#define EBADSLT 57

#define EDEADLOCK EDEADLK

#define EBFONT 59
#define ENOSTR 60
#define ENODATA 61
#define ETIME 62
#define ENOSR 63
#define ENONET 64
#define ENOPKG 65
#define EREMOTE 66
#define ENOLINK 67
#define EADV 68
#define ESRMNT 69
#define ECOMM 70
#define EPROTO 71
#define EMULTIHOP 72
#define EDOTDOT 73
#define EBADMSG 74
#define EOVERFLOW 75
#define ENOTUNIQ 76
#define EBADFD 77
#define EREMCHG 78
#define ELIBACC 79
#define ELIBBAD 80
#define ELIBSCN 81
#define ELIBMAX 82
#define ELIBEXEC 83
#define EILSEQ 84
#define ERESTART 85
#define ESTRPIPE 86
#define EUSERS 87
#define ENOTSOCK 88
#define EDESTADDRREQ 89
#define EMSGSIZE 90
#define EPROTOTYPE 91
#define ENOPROTOOPT 92
#define EPROTONOSUPPORT 93
#define ESOCKTNOSUPPORT 94
#define EOPNOTSUPP 95
#define EPFNOSUPPORT 96
#define EAFNOSUPPORT 97
#define EADDRINUSE 98
#define EADDRNOTAVAIL 99
#define ENETDOWN 100
#define ENETUNREACH 101
#define ENETRESET 102
#define ECONNABORTED 103
#define ECONNRESET 104
#define ENOBUFS 105
#define EISCONN 106
#define ENOTCONN 107
#define ESHUTDOWN 108
#define ETOOMANYREFS 109
#define ETIMEDOUT 110
#define ECONNREFUSED 111
#define EHOSTDOWN 112
#define EHOSTUNREACH 113
#define EALREADY 114
#define EINPROGRESS 115
#define ESTALE 116
#define EUCLEAN 117
#define ENOTNAM 118
#define ENAVAIL 119
#define EISNAM 120
#define EREMOTEIO 121
#define EDQUOT 122

#define ENOMEDIUM 123
#define EMEDIUMTYPE 124
# 5 "/usr/include/asm/errno.h" 2 3 4
# 5 "/usr/include/linux/errno.h" 2 3 4
# 26 "/usr/include/bits/errno.h" 2 3 4


#define ENOTSUP EOPNOTSUPP




#define ECANCELED 125




extern int *__errno_location (void) throw () __attribute__ ((__const__));



#define errno (*__errno_location ())
# 37 "/usr/include/errno.h" 2 3 4
# 55 "/usr/include/errno.h" 3 4
extern char *program_invocation_name, *program_invocation_short_name;



}
# 69 "/usr/include/errno.h" 3 4
typedef int error_t;
#define __error_t_defined 1
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cerrno" 2 3
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 2 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 1 3
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 3
#define _CPP_CMATH 1

       
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 3



# 1 "/usr/include/math.h" 1 3 4
# 25 "/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())
# 34 "/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())
# 36 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/huge_vall.h" 1 3 4
# 27 "/usr/include/bits/huge_vall.h" 3 4
#define HUGE_VALL (__builtin_huge_vall())
# 37 "/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())
# 40 "/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(""))
# 43 "/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




typedef long double float_t;

typedef long double double_t;



#define FP_ILOGB0 (-2147483647 - 1)
#define FP_ILOGBNAN (-2147483647 - 1)
# 47 "/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 ();
# 71 "/usr/include/math.h" 2 3 4
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
# 83 "/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 ();
# 94 "/usr/include/math.h" 2 3 4
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME






#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 ();
# 115 "/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;
# 171 "/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))
# 202 "/usr/include/math.h" 3 4
#define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x) : sizeof (x) == sizeof (double) ? __signbit (x) : __signbitl (x))
# 214 "/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))
# 242 "/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





typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 280 "/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
# 323 "/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







#define __NO_MATH_INLINES 1
# 372 "/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)




# 1 "/usr/include/bits/mathinline.h" 1 3 4
# 27 "/usr/include/bits/mathinline.h" 3 4
#define __MATH_INLINE __inline
# 127 "/usr/include/bits/mathinline.h" 3 4
__inline int
__signbitf (float __x) throw ()
{
  __extension__ union { float __f; int __i; } __u = { __f: __x };
  return __u.__i < 0;
}
__inline int
__signbit (double __x) throw ()
{
  __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
  return __u.__i[1] < 0;
}
__inline int
__signbitl (long double __x) throw ()
{
  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
  return (__u.__i[2] & 0x8000) != 0;
}
# 383 "/usr/include/math.h" 2 3 4
# 438 "/usr/include/math.h" 3 4
}
# 52 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 2 3
# 80 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 3
namespace __gnu_cxx
{
  namespace __c99_binding
  {
# 107 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 3
    using ::acosf;


    using ::asinf;


    using ::atanf;


    using ::atan2f;


    using ::ceilf;


    using ::coshf;


    using ::expf;


    using ::floorf;


    using ::fmodf;


    using ::frexpf;


    using ::ldexpf;


    using ::logf;


    using ::log10f;


    using ::modff;


    using ::powf;


    using ::sinhf;


    using ::tanf;


    using ::tanhf;


  }
}

namespace std
{


  template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);

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


  inline float
  acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); }





  using ::acos;


  inline long double
  acos(long double __x) { return ::acosl(__x); }





  using ::asin;


  inline float
  asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); }






  inline long double
  asin(long double __x) { return ::asinl(__x); }





  using ::atan;


  inline float
  atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); }






  inline long double
  atan(long double __x) { return ::atanl(__x); }





  using ::atan2;


  inline float
  atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); }







  inline long double
  atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }






  using ::ceil;


  inline float
  ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); }






  inline long double
  ceil(long double __x) { return ::ceill(__x); }





  using ::cos;

  inline float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline long double
  cos(long double __x)
  { return __builtin_cosl(__x); }

  using ::cosh;


  inline float
  cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); }






  inline long double
  cosh(long double __x) { return ::coshl(__x); }





  using ::exp;


  inline float
  exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); }






  inline long double
  exp(long double __x) { return ::expl(__x); }





  using ::fabs;

  inline float
  fabs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  fabs(long double __x)
  { return __builtin_fabsl(__x); }

  using ::floor;


  inline float
  floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); }






  inline long double
  floor(long double __x) { return ::floorl(__x); }





  using ::fmod;


  inline float
  fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); }







  inline long double
  fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }






  using ::frexp;


  inline float
  frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); }






  inline long double
  frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }






  using ::ldexp;


  inline float
  ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); }







  inline long double
  ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }






  using ::log;


  inline float
  log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); }






  inline long double
  log(long double __x) { return ::logl(__x); }





  using ::log10;


  inline float
  log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); }






  inline long double
  log10(long double __x) { return ::log10l(__x); }





  using ::modf;


  inline float
  modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); }
# 460 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 3
  inline long double
  modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
# 473 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 3
  template<typename _Tp>
    inline _Tp
    __pow_helper(_Tp __x, int __n)
    {
      return __n < 0
        ? _Tp(1)/__cmath_power(__x, -__n)
        : __cmath_power(__x, __n);
    }

  using ::pow;


  inline float
  pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); }







  inline long double
  pow(long double __x, long double __y) { return ::powl(__x, __y); }






  inline double
  pow(double __x, int __i)
  { return __pow_helper(__x, __i); }

  inline float
  pow(float __x, int __n)
  { return __pow_helper(__x, __n); }

  inline long double
  pow(long double __x, int __n)
  { return __pow_helper(__x, __n); }

  using ::sin;

  inline float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline long double
  sin(long double __x)
  { return __builtin_sinl(__x); }

  using ::sinh;


  inline float
  sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); }






  inline long double
  sinh(long double __x) { return ::sinhl(__x); }





  using ::sqrt;

  inline float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }

  using ::tan;


  inline float
  tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); }






  inline long double
  tan(long double __x) { return ::tanl(__x); }





  using ::tanh;


  inline float
  tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); }






  inline long double
  tanh(long double __x) { return ::tanhl(__x); }




}







namespace __gnu_cxx
{
  template<typename _Tp>
    int
    __capture_fpclassify(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __fpclassifyf (__f) : sizeof (__f) == sizeof (double) ? __fpclassify (__f) : __fpclassifyl (__f)); }

  template<typename _Tp>
    int
    __capture_isfinite(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __finitef (__f) : sizeof (__f) == sizeof (double) ? __finite (__f) : __finitel (__f)); }

  template<typename _Tp>
    int
    __capture_isinf(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __isinff (__f) : sizeof (__f) == sizeof (double) ? __isinf (__f) : __isinfl (__f)); }

  template<typename _Tp>
    int
    __capture_isnan(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __isnanf (__f) : sizeof (__f) == sizeof (double) ? __isnan (__f) : __isnanl (__f)); }

  template<typename _Tp>
    int
    __capture_isnormal(_Tp __f) { return ((sizeof (__f) == sizeof (float) ? __fpclassifyf (__f) : sizeof (__f) == sizeof (double) ? __fpclassify (__f) : __fpclassifyl (__f)) == FP_NORMAL); }

  template<typename _Tp>
    int
    __capture_signbit(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __signbitf (__f) : sizeof (__f) == sizeof (double) ? __signbit (__f) : __signbitl (__f)); }

  template<typename _Tp>
    int
    __capture_isgreater(_Tp __f1, _Tp __f2)
    { return __builtin_isgreater(__f1, __f2); }

  template<typename _Tp>
     int
     __capture_isgreaterequal(_Tp __f1, _Tp __f2)
     { return __builtin_isgreaterequal(__f1, __f2); }

  template<typename _Tp>
     int
     __capture_isless(_Tp __f1, _Tp __f2) { return __builtin_isless(__f1, __f2); }

  template<typename _Tp>
     int
     __capture_islessequal(_Tp __f1, _Tp __f2)
     { return __builtin_islessequal(__f1, __f2); }

  template<typename _Tp>
     int
     __capture_islessgreater(_Tp __f1, _Tp __f2)
     { return __builtin_islessgreater(__f1, __f2); }

  template<typename _Tp>
     int
     __capture_isunordered(_Tp __f1, _Tp __f2)
     { return __builtin_isunordered(__f1, __f2); }
}



#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 __gnu_cxx
{
  template<typename _Tp>
    int
    fpclassify(_Tp __f) { return __capture_fpclassify(__f); }

  template<typename _Tp>
    int
    isfinite(_Tp __f) { return __capture_isfinite(__f); }

  template<typename _Tp>
    int
    isinf(_Tp __f) { return __capture_isinf(__f); }

  template<typename _Tp>
    int
    isnan(_Tp __f) { return __capture_isnan(__f); }

  template<typename _Tp>
    int
    isnormal(_Tp __f) { return __capture_isnormal(__f); }

  template<typename _Tp>
    int
    signbit(_Tp __f) { return __capture_signbit(__f); }

  template<typename _Tp>
    int
    isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }

  template<typename _Tp>
    int
    isgreaterequal(_Tp __f1, _Tp __f2)
    { return __capture_isgreaterequal(__f1, __f2); }

  template<typename _Tp>
    int
    isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }

  template<typename _Tp>
    int
    islessequal(_Tp __f1, _Tp __f2)
    { return __capture_islessequal(__f1, __f2); }

  template<typename _Tp>
    int
    islessgreater(_Tp __f1, _Tp __f2)
    { return __capture_islessgreater(__f1, __f2); }

  template<typename _Tp>
    int
    isunordered(_Tp __f1, _Tp __f2)
    { return __capture_isunordered(__f1, __f2); }
}

namespace std
{
  using __gnu_cxx::fpclassify;
  using __gnu_cxx::isfinite;
  using __gnu_cxx::isinf;
  using __gnu_cxx::isnan;
  using __gnu_cxx::isnormal;
  using __gnu_cxx::signbit;
  using __gnu_cxx::isgreater;
  using __gnu_cxx::isgreaterequal;
  using __gnu_cxx::isless;
  using __gnu_cxx::islessequal;
  using __gnu_cxx::islessgreater;
  using __gnu_cxx::isunordered;
}




#define export 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/cmath.tcc" 1 3
# 33 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/cmath.tcc" 3
#define _CPP_BITS_CMATH_TCC 1

namespace std
{
  template<typename _Tp>
    _Tp
    __cmath_power(_Tp __x, unsigned int __n)
    {
      _Tp __y = __n % 2 ? __x : 1;

      while (__n >>= 1)
        {
          __x = __x * __x;
          if (__n % 2)
            __y = __y * __x;
        }

      return __y;
    }
}
# 744 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cmath" 2 3
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 2 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/limits" 1 3
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/limits" 3
#define _CPP_NUMERIC_LIMITS 1

       
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/limits" 3
# 86 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/limits" 3
#define __glibcpp_integral_traps true
# 95 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/limits" 3
#define __glibcpp_float_has_denorm_loss false


#define __glibcpp_float_traps false


#define __glibcpp_float_tinyness_before false







#define __glibcpp_double_has_denorm_loss false


#define __glibcpp_double_traps false


#define __glibcpp_double_tinyness_before false







#define __glibcpp_long_double_has_denorm_loss false


#define __glibcpp_long_double_traps false


#define __glibcpp_long_double_tinyness_before false




#define __glibcpp_signed(T) ((T)(-1) < 0)

#define __glibcpp_min(T) (__glibcpp_signed (T) ? (T)1 << __glibcpp_digits (T) : (T)0)


#define __glibcpp_max(T) (__glibcpp_signed (T) ? ((T)1 << __glibcpp_digits (T)) - 1 : ~(T)0)


#define __glibcpp_digits(T) (sizeof(T) * __CHAR_BIT__ - __glibcpp_signed (T))



#define __glibcpp_digits10(T) (__glibcpp_digits (T) * 643 / 2136)



namespace std
{
  enum float_round_style
  {
    round_indeterminate = -1,
    round_toward_zero = 0,
    round_to_nearest = 1,
    round_toward_infinity = 2,
    round_toward_neg_infinity = 3
  };

  enum float_denorm_style
  {
    denorm_indeterminate = -1,
    denorm_absent = 0,
    denorm_present = 1
  };




  struct __numeric_limits_base
  {
    static const bool is_specialized = false;

    static const int digits = 0;
    static const int digits10 = 0;
    static const bool is_signed = false;
    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int radix = 0;

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

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

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

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

  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {
      static _Tp min() throw() { return static_cast<_Tp>(0); }
      static _Tp max() throw() { return static_cast<_Tp>(0); }
      static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
      static _Tp round_error() throw() { return static_cast<_Tp>(0); }
      static _Tp infinity() throw() { return static_cast<_Tp>(0); }
      static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
      static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
      static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
    };



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

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

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

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

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

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

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




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

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

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

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

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

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

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

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

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

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

      static signed char min() throw()
      { return -127 - 1; }
      static signed char max() throw()
      { return 127; }

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

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

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

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

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

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

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

      static unsigned char min() throw()
      { return 0; }
      static unsigned char max() throw()
      { return 127 * 2U + 1; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      static unsigned short min() throw()
      { return 0; }
      static unsigned short max() throw()
      { return 32767 * 2U + 1; }

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

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

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

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

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

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

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

      static int min() throw()
      { return -2147483647 - 1; }
      static int max() throw()
      { return 2147483647; }

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

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

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

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

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

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

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

      static unsigned int min() throw()
      { return 0; }
      static unsigned int max() throw()
      { return 2147483647 * 2U + 1; }

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

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

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

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

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

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

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

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

      static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 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 2147483647L * 2UL + 1; }

      static const int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 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
        = __builtin_huge_valf () / 2 == __builtin_huge_valf ();
      static const bool has_quiet_NaN
        = __builtin_nanf ("") != __builtin_nanf ("");
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
        = 1.40129846e-45F ? denorm_present : denorm_absent;
      static const bool has_denorm_loss = false;

      static float infinity() throw()
      { return __builtin_huge_valf (); }
      static float quiet_NaN() throw()
      { return __builtin_nanf (""); }
      static float signaling_NaN() throw()
      { return __builtin_nansf (""); }
      static float denorm_min() throw()
      { return 1.40129846e-45F; }

      static const bool is_iec559
        = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_to_nearest;
    };

#undef __glibcpp_float_has_denorm_loss
#undef __glibcpp_float_traps
#undef __glibcpp_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
        = __builtin_huge_val () / 2 == __builtin_huge_val ();
      static const bool has_quiet_NaN
        = __builtin_nan ("") != __builtin_nan ("");
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
        = 4.9406564584124654e-324 ? denorm_present : denorm_absent;
      static const bool has_denorm_loss = false;

      static double infinity() throw()
      { return __builtin_huge_val(); }
      static double quiet_NaN() throw()
      { return __builtin_nan (""); }
      static double signaling_NaN() throw()
      { return __builtin_nans (""); }
      static double denorm_min() throw()
      { return 4.9406564584124654e-324; }

      static const bool is_iec559
        = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_to_nearest;
    };

#undef __glibcpp_double_has_denorm_loss
#undef __glibcpp_double_traps
#undef __glibcpp_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
        = __builtin_huge_vall () / 2 == __builtin_huge_vall ();
      static const bool has_quiet_NaN
        = __builtin_nanl ("") != __builtin_nanl ("");
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
        = 3.64519953188247460253e-4951L ? denorm_present : denorm_absent;
      static const bool has_denorm_loss
        = false;

      static long double infinity() throw()
      { return __builtin_huge_vall (); }
      static long double quiet_NaN() throw()
      { return __builtin_nanl (""); }
      static long double signaling_NaN() throw()
      { return __builtin_nansl (""); }
      static long double denorm_min() throw()
      { return 3.64519953188247460253e-4951L; }

      static const bool is_iec559
        = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_to_nearest;
    };

#undef __glibcpp_long_double_has_denorm_loss
#undef __glibcpp_long_double_traps
#undef __glibcpp_long_double_tinyness_before

}

#undef __glibcpp_signed
#undef __glibcpp_min
#undef __glibcpp_max
#undef __glibcpp_digits
#undef __glibcpp_digits10
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/typeinfo" 1 3
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/typeinfo" 3
#define __TYPEINFO__ 



extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}






#define __GXX_MERGED_TYPEINFO_NAMES 1


namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();

  private:

    type_info& operator=(const type_info&);
    type_info(const type_info&);

  protected:
    const char *__name;

  protected:
    explicit type_info(const char *__n): __name(__n) { }

  public:



    const char* name() const
    { return __name; }
# 101 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/typeinfo" 3
    bool before(const type_info& __arg) const
    { return __name < __arg.__name; }
    bool operator==(const type_info& __arg) const
    { return __name == __arg.__name; }

    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }


  public:

    virtual bool __is_pointer_p() const;

    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
                            unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
                             void **__obj_ptr) const;
  };






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


    virtual ~bad_cast() throw();
  };


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


    virtual ~bad_typeid() throw();
  };
}

}
# 45 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 2 3


namespace std
{
  template<typename _Facet>
    locale
    locale::combine(const locale& __other) const
    {
      _Impl* __tmp = new _Impl(*_M_impl, 1);
      try
        {
          __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
        }
      catch(...)
        {
          __tmp->_M_remove_reference();
          throw;
        }
      return locale(__tmp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
                       const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
                                __s2.data(), __s2.data() + __s2.length()) < 0);
    }

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc)
    {
      size_t __i = _Facet::id._M_id();
      locale::facet** __facets = __loc._M_impl->_M_facets;
      if (!(__i < __loc._M_impl->_M_facets_size && __facets[__i]))
        __throw_bad_cast();
      return static_cast<const _Facet&>(*__facets[__i]);
    }

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw()
    {
      size_t __i = _Facet::id._M_id();
      locale::facet** __facets = __loc._M_impl->_M_facets;
      return (__i < __loc._M_impl->_M_facets_size && __facets[__i]);
    }



  template<typename _Facet>
    inline const __locale_cache<_Facet>&
    __use_cache(const locale& __loc)
    {
      size_t __i = _Facet::id._M_id();
      if (__builtin_expect(__i >= __loc._M_impl->_M_facets_size,false))
        __throw_bad_cast();
      __locale_cache_base* __cache = __loc._M_impl->_M_get_cache(__i);
      if (__builtin_expect(!__cache, false))
        {
          __cache = new __locale_cache<_Facet>(__loc);
          __loc._M_impl->_M_install_cache(__cache, __i);
        }
      return static_cast<const __locale_cache<_Facet>&>(*__cache);
    }


  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;
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);


      const char_type __plus = __ctype.widen('+');
      const char_type __minus = __ctype.widen('-');
      int __pos = 0;
      char_type __c = *__beg;
      if ((__traits_type::eq(__c, __plus) || __traits_type::eq(__c, __minus))
          && __beg != __end)
        {
          __xtrc += __ctype.narrow(__c, char());
          ++__pos;
          __c = *(++__beg);
        }


      const char_type __zero = __ctype.widen(_S_atoms_in[_M_zero]);
      bool __found_zero = false;
      while (__traits_type::eq(__c, __zero) && __beg != __end)
        {
          __c = *(++__beg);
          __found_zero = true;
        }
      if (__found_zero)
        {
          __xtrc += _S_atoms_in[_M_zero];
          ++__pos;
        }


      const size_t __len = _M_E - _M_zero + 1;
      char_type __watoms[__len];
      __ctype.widen(_S_atoms_in, _S_atoms_in + __len, __watoms);
      bool __found_dec = false;
      bool __found_sci = false;
      const char_type __dec = __np.decimal_point();

      string __found_grouping;
      const string __grouping = __np.grouping();
      bool __check_grouping = __grouping.size();
      int __sep_pos = 0;
      const char_type __sep = __np.thousands_sep();

      while (__beg != __end)
        {

          const char_type* __p = __traits_type::find(__watoms, 10, __c);


          if (__p && !__traits_type::eq(__c, char_type()))
            {

              ++__pos;
              __xtrc += _S_atoms_in[__p - __watoms];
              ++__sep_pos;
              __c = *(++__beg);
            }
          else if (__traits_type::eq(__c, __sep)
                   && __check_grouping && !__found_dec)
            {


              if (__sep_pos)
                {
                  __found_grouping += static_cast<char>(__sep_pos);
                  __sep_pos = 0;
                  __c = *(++__beg);
                }
              else
                {
                  __err |= ios_base::failbit;
                  break;
                }
            }
          else if (__traits_type::eq(__c, __dec) && !__found_dec)
            {



              if (__found_grouping.size())
                __found_grouping += static_cast<char>(__sep_pos);
              ++__pos;
              __xtrc += '.';
              __c = *(++__beg);
              __found_dec = true;
            }
          else if ((__traits_type::eq(__c, __watoms[_M_e])
                    || __traits_type::eq(__c, __watoms[_M_E]))
                   && !__found_sci && __pos)
            {

              ++__pos;
              __xtrc += __ctype.narrow(__c, char());
              __c = *(++__beg);


              if (__traits_type::eq(__c, __plus)
                  || __traits_type::eq(__c, __minus))
                {
                  ++__pos;
                  __xtrc += __ctype.narrow(__c, char());
                  __c = *(++__beg);
                }
              __found_sci = true;
            }
          else

            break;
        }



      if (__check_grouping && __found_grouping.size())
        {

          if (!__found_dec)
            __found_grouping += static_cast<char>(__sep_pos);
          if (!__verify_grouping(__grouping, __found_grouping))
            __err |= ios_base::failbit;
        }


      __xtrc += char();
      if (__beg == __end)
        __err |= ios_base::eofbit;
      return __beg;
    }


  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
                   ios_base::iostate& __err, string& __xtrc, int& __base) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);


      ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
      if (__basefield == ios_base::oct)
        __base = 8;
      else if (__basefield == ios_base::hex)
        __base = 16;
      else
        __base = 10;


      int __pos = 0;
      char_type __c = *__beg;
      const char_type __plus = __ctype.widen('+');
      const char_type __minus = __ctype.widen('-');

      if ((__traits_type::eq(__c, __plus) || __traits_type::eq(__c, __minus))
          && __beg != __end)
        {
          __xtrc += __ctype.narrow(__c, char());
          ++__pos;
          __c = *(++__beg);
        }


      const char_type __zero = __ctype.widen(_S_atoms_in[_M_zero]);
      const char_type __x = __ctype.widen('x');
      const char_type __X = __ctype.widen('X');
      if (__base == 10)
        {
          bool __found_zero = false;
          while (__traits_type::eq(__c, __zero) && __beg != __end)
            {
              __c = *(++__beg);
              __found_zero = true;
            }
          if (__found_zero)
            {
              __xtrc += _S_atoms_in[_M_zero];
              ++__pos;
              if (__basefield == 0)
                {
                  if ((__traits_type::eq(__c, __x)
                       || __traits_type::eq(__c, __X))
                      && __beg != __end)
                    {
                      __xtrc += __ctype.narrow(__c, char());
                      ++__pos;
                      __c = *(++__beg);
                      __base = 16;
                    }
                  else
                    __base = 8;
                }
            }
        }
      else if (__base == 16)
        {
          if (__traits_type::eq(__c, __zero) && __beg != __end)
            {
              __xtrc += _S_atoms_in[_M_zero];
              ++__pos;
              __c = *(++__beg);
              if ((__traits_type::eq(__c, __x) || __traits_type::eq(__c, __X))
                  && __beg != __end)
                {
                  __xtrc += __ctype.narrow(__c, char());
                  ++__pos;
                  __c = *(++__beg);
                }
            }
        }



      size_t __len;
      if (__base == 16)
        __len = _M_size;
      else
        __len = __base;


      char_type __watoms[_M_size];
      __ctype.widen(_S_atoms_in, _S_atoms_in + __len, __watoms);
      string __found_grouping;
      const string __grouping = __np.grouping();
      bool __check_grouping = __grouping.size();
      int __sep_pos = 0;
      const char_type __sep = __np.thousands_sep();
      while (__beg != __end)
        {
          const char_type* __p = __traits_type::find(__watoms, __len, __c);


          if (__p && !__traits_type::eq(__c, char_type()))
            {

              __xtrc += _S_atoms_in[__p - __watoms];
              ++__pos;
              ++__sep_pos;
              __c = *(++__beg);
            }
          else if (__traits_type::eq(__c, __sep) && __check_grouping)
            {


              if (__sep_pos)
                {
                  __found_grouping += static_cast<char>(__sep_pos);
                  __sep_pos = 0;
                  __c = *(++__beg);
                }
              else
                {
                  __err |= ios_base::failbit;
                  break;
                }
            }
          else

            break;
        }



      if (__check_grouping && __found_grouping.size())
        {

          __found_grouping += static_cast<char>(__sep_pos);
          if (!__verify_grouping(__grouping, __found_grouping))
            __err |= ios_base::failbit;
        }


      __xtrc += char();
      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, bool& __v) const
    {

      if (!(__io.flags() & ios_base::boolalpha))
        {


          string __xtrc;
          int __base;
          __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);

          unsigned long __ul;
          __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
          if (!(__err & ios_base::failbit) && __ul <= 1)
            __v = __ul;
          else
            __err |= ios_base::failbit;
        }


      else
        {
          typedef char_traits<_CharT> __traits_type;
          typedef basic_string<_CharT> __string_type;

          locale __loc = __io.getloc();
          const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
          const __string_type __true = __np.truename();
          const __string_type __false = __np.falsename();
          const char_type* __trues = __true.c_str();
          const char_type* __falses = __false.c_str();
          const size_t __truen = __true.size() - 1;
          const size_t __falsen = __false.size() - 1;

          for (size_t __n = 0; __beg != __end; ++__n)
            {
              char_type __c = *__beg++;
              bool __testf = __n <= __falsen
                             ? __traits_type::eq(__c, __falses[__n]) : false;
              bool __testt = __n <= __truen
                             ? __traits_type::eq(__c, __trues[__n]) : false;
              if (!(__testf || __testt))
                {
                  __err |= ios_base::failbit;
                  break;
                }
              else if (__testf && __n == __falsen)
                {
                  __v = 0;
                  break;
                }
              else if (__testt && __n == __truen)
                {
                  __v = 1;
                  break;
                }
            }
          if (__beg == __end)
            __err |= ios_base::eofbit;
        }
      return __beg;
    }


  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long& __v) const
    {
      string __xtrc;
      int __base;
      __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
      __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
      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, unsigned short& __v) const
    {
      string __xtrc;
      int __base;
      __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
      unsigned long __ul;
      __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
      if (!(__err & ios_base::failbit)
          && __ul <= numeric_limits<unsigned short>::max())
        __v = static_cast<unsigned short>(__ul);
      else
        __err |= ios_base::failbit;
      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, unsigned int& __v) const
    {
      string __xtrc;
      int __base;
      __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
      unsigned long __ul;
      __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
      if (!(__err & ios_base::failbit)
          && __ul <= numeric_limits<unsigned int>::max())
        __v = static_cast<unsigned int>(__ul);
      else
        __err |= ios_base::failbit;
      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, unsigned long& __v) const
    {
      string __xtrc;
      int __base;
      __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
      __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
      return __beg;
    }


  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long long& __v) const
    {
      string __xtrc;
      int __base;
      __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
      __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
      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, unsigned long long& __v) const
    {
      string __xtrc;
      int __base;
      __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
      __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
      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);
      __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      fmtflags __fmt = __io.flags();
      fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
                             | ios_base::uppercase | ios_base::internal);
      __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));

      string __xtrc;
      int __base;
      __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);


      __io.flags(__fmt);

      unsigned long __ul;
      __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
      if (!(__err & ios_base::failbit))
        __v = reinterpret_cast<void*>(__ul);
      else
        __err |= ios_base::failbit;
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
           _CharT* __new, const _CharT* __cs, int& __len) const
    {


      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs,
                                                  __w, __len, true);
      __len = static_cast<int>(__w);
    }


  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __out, const int __size, long __v,
                       const _CharT* __lit, ios_base::fmtflags __flags)
    {
      unsigned long __ul = static_cast<unsigned long>(__v);
      bool __neg = false;
      if (__v < 0)
        {
          __ul = -__ul;
          __neg = true;
        }
      return __int_to_char(__out, __size, __ul, __lit, __flags, __neg);
    }

  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __out, const int __size, unsigned long __v,
                       const _CharT* __lit, ios_base::fmtflags __flags)
    { return __int_to_char(__out, __size, __v, __lit, __flags, false); }


  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __out, const int __size, long long __v,
                       const _CharT* __lit, ios_base::fmtflags __flags)
    {
      unsigned long long __ull = static_cast<unsigned long long>(__v);
      bool __neg = false;
      if (__v < 0)
        {
          __ull = -__ull;
          __neg = true;
        }
      return __int_to_char(__out, __size, __ull, __lit, __flags, __neg);
    }

  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __out, const int __size, unsigned long long __v,
                       const _CharT* __lit, ios_base::fmtflags __flags)
    { return __int_to_char(__out, __size, __v, __lit, __flags, false); }


  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __out, const int __size, _ValueT __v,
                  const _CharT* __lit, ios_base::fmtflags __flags, bool __neg)
    {

      const bool __showbase = (__flags & ios_base::showbase) && __v;
      const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
      _CharT* __buf = __out + __size - 1;
      _CharT* __bufend = __out + __size;

      if (__builtin_expect(__basefield != ios_base::oct &&
                           __basefield != ios_base::hex, true))
        {

          do
            {
              *__buf-- = __lit[(__v % 10) + __num_base::_S_digits];
              __v /= 10;
            }
          while (__v != 0);
          if (__neg)
            *__buf-- = __lit[__num_base::_S_minus];
          else if (__flags & ios_base::showpos)
            *__buf-- = __lit[__num_base::_S_plus];
        }
      else if (__basefield == ios_base::oct)
        {

          do
            {
              *__buf-- = __lit[(__v & 0x7) + __num_base::_S_digits];
              __v >>= 3;
            }
          while (__v != 0);
          if (__showbase)
            *__buf-- = __lit[__num_base::_S_digits];
        }
      else
        {

          const bool __uppercase = __flags & ios_base::uppercase;
          int __case_offset = __uppercase
                              ? __num_base::_S_udigits : __num_base::_S_digits;
          do
            {
              *__buf-- = __lit[(__v & 0xf) + __case_offset];
              __v >>= 4;
            }
          while (__v != 0);
          if (__showbase)
            {

              *__buf-- = __lit[__num_base::_S_x + __uppercase];

              *__buf-- = __lit[__num_base::_S_digits];
            }
        }
      int __ret = __bufend - __buf - 1;
      return __ret;
    }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_int(const string& __grouping, _CharT __sep, ios_base& __io,
                 _CharT* __new, _CharT* __cs, int& __len) const
    {





      streamsize __off = 0;
      const ios_base::fmtflags __basefield = __io.flags()
                                             & ios_base::basefield;
      if ((__io.flags() & ios_base::showbase) && __len > 1)
        if (__basefield == ios_base::oct)
          {
            __off = 1;
            *__new = *__cs;
          }
        else if (__basefield == ios_base::hex)
          {
            __off = 2;
            *__new = *__cs;
            *(__new + 1) = *(__cs + 1);
          }
      _CharT* __p;
      __p = __add_grouping(__new + __off, __sep,
                           __grouping.c_str(),
                           __grouping.c_str() + __grouping.size(),
                           __cs + __off, __cs + __len);
      __len = __p - __new;
    }

  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill,
                     _ValueT __v) const
      {
        typedef numpunct<_CharT> __facet_type;
        typedef __locale_cache<numpunct<_CharT> > __cache_type;
        const locale& __loc = __io._M_getloc();
        const __cache_type& __lc = __use_cache<__facet_type>(__loc);
        const _CharT* __lit = __lc._M_atoms_out;


        int __ilen = 4 * sizeof(_ValueT);
        _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                             * __ilen));


        int __len;
        __len = __int_to_char(&__cs[0], __ilen, __v, __lit, __io.flags());
        __cs = __cs + __ilen - __len;


        _CharT* __cs2;
        if (__lc._M_use_grouping)
          {


            __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                          * __len * 2));
            _M_group_int(__lc._M_grouping, __lc._M_thousands_sep, __io,
                         __cs2, __cs, __len);
            __cs = __cs2;
          }


        _CharT* __cs3;
        streamsize __w = __io.width();
        if (__w > static_cast<streamsize>(__len))
          {
            __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                          * __w));
            _M_pad(__fill, __w, __io, __cs3, __cs, __len);
            __cs = __cs3;
          }
        __io.width(0);



        return __write(__s, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_float(const string& __grouping, _CharT __sep, const _CharT* __p,
                   _CharT* __new, _CharT* __cs, int& __len) const
    {



      _CharT* __p2;
      int __declen = __p ? __p - __cs : __len;
      __p2 = __add_grouping(__new, __sep,
                            __grouping.c_str(),
                            __grouping.c_str() + __grouping.size(),
                            __cs, __cs + __declen);


      int __newlen = __p2 - __new;
      if (__p)
        {
          char_traits<_CharT>::copy(__p2, __p, __len - __declen);
          __newlen += __len - __declen;
        }
      __len = __newlen;

    }
# 880 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_convert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
                       _ValueT __v) const
      {

        streamsize __prec = __io.precision();
        if (__prec < static_cast<streamsize>(0))
          __prec = static_cast<streamsize>(6);

        const int __max_digits = numeric_limits<_ValueT>::digits10;

        typedef numpunct<_CharT> __facet_type;
        typedef __locale_cache<numpunct<_CharT> > __cache_type;
        const locale __loc = __io._M_getloc();
        const __cache_type& __lc = __use_cache<__facet_type>(__loc);


        int __len;

        char __fbuf[16];




        int __cs_size = __max_digits * 3;
        char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));

        _S_format_float(__io, __fbuf, __mod, __prec);
        __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
                                 _S_c_locale, __prec);


        if (__len >= __cs_size)
          {
            __cs_size = __len + 1;
            __cs = static_cast<char*>(__builtin_alloca(__cs_size));
            __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
                                     _S_c_locale, __prec);
          }
# 942 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 3
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                           * __len));
      __ctype.widen(__cs, __cs + __len, __ws);


      const _CharT __cdec = __ctype.widen('.');
      const _CharT __dec = __lc._M_decimal_point;
      const _CharT* __p;
      if (__p = char_traits<_CharT>::find(__ws, __len, __cdec))
        __ws[__p - __ws] = __dec;


      _CharT* __ws2;
      if (__lc._M_use_grouping)
        {


            __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                          * __len * 2));
            _M_group_float(__lc._M_grouping, __lc._M_thousands_sep, __p,
                           __ws2, __ws, __len);
            __ws = __ws2;
        }


      _CharT* __ws3;
      streamsize __w = __io.width();
      if (__w > static_cast<streamsize>(__len))
        {
          __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
          _M_pad(__fill, __w, __io, __ws3, __ws, __len);
          __ws = __ws3;
        }
      __io.width(0);



      return __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
    {
      ios_base::fmtflags __flags = __io.flags();
      if ((__flags & ios_base::boolalpha) == 0)
        {
          unsigned long __uv = __v;
          __s = _M_convert_int(__s, __io, __fill, __uv);
        }
      else
        {
          typedef numpunct<_CharT> __facet_type;
          typedef __locale_cache<numpunct<_CharT> > __cache_type;
          const locale __loc = __io._M_getloc();
          const __cache_type& __lc = __use_cache<__facet_type>(__loc);

          typedef basic_string<_CharT> __string_type;
          __string_type __name;
          if (__v)
            __name = __lc._M_truename;
          else
            __name = __lc._M_falsename;

          const _CharT* __cs = __name.c_str();
          int __len = __name.size();
          _CharT* __cs3;
          streamsize __w = __io.width();
          if (__w > static_cast<streamsize>(__len))
            {
              __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                            * __w));
              _M_pad(__fill, __w, __io, __cs3, __cs, __len);
              __cs = __cs3;
            }
          __io.width(0);
          __s = __write(__s, __cs, __len);
        }
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
    { return _M_convert_int(__s, __io, __fill, __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           unsigned long __v) const
    { return _M_convert_int(__s, __io, __fill, __v); }


  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const
    { return _M_convert_int(__s, __b, __fill, __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           unsigned long long __v) const
    { return _M_convert_int(__s, __io, __fill, __v); }


  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    { return _M_convert_float(__s, __io, __fill, char(), __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           long double __v) const
    { return _M_convert_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
    {
      ios_base::fmtflags __flags = __io.flags();
      ios_base::fmtflags __fmt = ~(ios_base::showpos | ios_base::basefield
                                   | ios_base::uppercase | ios_base::internal);
      __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
      try
        {
          __s = _M_convert_int(__s, __io, __fill,
                               reinterpret_cast<unsigned long>(__v));
          __io.flags(__flags);
        }
      catch (...)
        {
          __io.flags(__flags);
          throw;
        }
      return __s;
    }


  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_type __str;
      __beg = this->do_get(__beg, __end, __intl, __io, __err, __str);

      const int __cs_size = __str.size() + 1;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const _CharT* __wcs = __str.c_str();
      __ctype.narrow(__wcs, __wcs + __cs_size, char(), __cs);
      __convert_to_v(__cs, __units, __err, _S_c_locale);
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
           ios_base::iostate& __err, string_type& __units) const
    {

      typedef moneypunct<_CharT, true> __money_true;
      typedef moneypunct<_CharT, false> __money_false;
      typedef money_base::part part;
      typedef typename string_type::size_type size_type;

      const locale __loc = __io.getloc();
      const __money_true& __mpt = use_facet<__money_true>(__loc);
      const __money_false& __mpf = use_facet<__money_false>(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      const money_base::pattern __p = __intl ? __mpt.neg_format()
                                             : __mpf.neg_format();

      const string_type __pos_sign =__intl ? __mpt.positive_sign()
                                           : __mpf.positive_sign();
      const string_type __neg_sign =__intl ? __mpt.negative_sign()
                                           : __mpf.negative_sign();
      const char_type __d = __intl ? __mpt.decimal_point()
                                   : __mpf.decimal_point();
      const char_type __sep = __intl ? __mpt.thousands_sep()
                                     : __mpf.thousands_sep();

      const string __grouping = __intl ? __mpt.grouping() : __mpf.grouping();


      string_type __sign;

      string __grouping_tmp;

      int __sep_pos = 0;

      bool __testvalid = true;

      bool __testdecfound = false;


      string_type __temp_units;

      char_type __c = *__beg;
      char_type __eof = static_cast<char_type>(char_traits<char_type>::eof());
      for (int __i = 0; __beg != __end && __i < 4 && __testvalid; ++__i)
        {
          part __which = static_cast<part>(__p.field[__i]);
          switch (__which)
                {
                case money_base::symbol:
                  if (__io.flags() & ios_base::showbase
                      || __i < 2 || __sign.size() > 1
                      || ((static_cast<part>(__p.field[3]) != money_base::none)
                          && __i == 2))
                    {





                      const string_type __symbol = __intl ? __mpt.curr_symbol()
                                                         : __mpf.curr_symbol();
                      size_type __len = __symbol.size();
                      size_type __j = 0;
                      while (__beg != __end
                             && __j < __len && __symbol[__j] == __c)
                        {
                          __c = *(++__beg);
                          ++__j;
                        }


                      if (__j != __len && (__io.flags() & ios_base::showbase))
                        __testvalid = false;
                    }
                  break;
                case money_base::sign:

                  if (__pos_sign.size() && __neg_sign.size())
                  {

                    if (__c == __pos_sign[0])
                      {
                        __sign = __pos_sign;
                        __c = *(++__beg);
                      }
                    else if (__c == __neg_sign[0])
                      {
                        __sign = __neg_sign;
                        __c = *(++__beg);
                      }
                    else
                      __testvalid = false;
                  }
                  else if (__pos_sign.size() && __c == __pos_sign[0])
                    {
                      __sign = __pos_sign;
                      __c = *(++__beg);
                    }
                  else if (__neg_sign.size() && __c == __neg_sign[0])
                    {
                      __sign = __neg_sign;
                      __c = *(++__beg);
                    }
                  break;
                case money_base::value:


                  while (__beg != __end
                         && (__ctype.is(ctype_base::digit, __c)
                             || (__c == __d && !__testdecfound)
                             || __c == __sep))
                    {
                      if (__c == __d)
                        {
                          __grouping_tmp += static_cast<char>(__sep_pos);
                          __sep_pos = 0;
                          __testdecfound = true;
                        }
                      else if (__c == __sep)
                        {
                          if (__grouping.size())
                            {

                              __grouping_tmp += static_cast<char>(__sep_pos);
                              __sep_pos = 0;
                            }
                          else
                            {
                              __testvalid = false;
                              break;
                            }
                        }
                      else
                        {
                          __temp_units += __c;
                          ++__sep_pos;
                        }
                      __c = *(++__beg);
                    }
                  break;
                case money_base::space:
                case money_base::none:

                  if (__i != 3)
                    while (__beg != __end
                           && __ctype.is(ctype_base::space, __c))
                      __c = *(++__beg);
                  break;
                }
        }


      if (__sign.size() > 1)
        {
          size_type __len = __sign.size();
          size_type __i = 1;
          for (; __c != __eof && __i < __len; ++__i)
            while (__beg != __end && __c != __sign[__i])
              __c = *(++__beg);

          if (__i != __len)
            __testvalid = false;
        }


      while (__temp_units.size() > 1 && __temp_units[0] == __ctype.widen('0'))
        __temp_units.erase(__temp_units.begin());

      if (__sign.size() && __sign == __neg_sign)
        __temp_units.insert(__temp_units.begin(), __ctype.widen('-'));


      if (__grouping.size() && __grouping_tmp.size())
        {
          if (!__verify_grouping(__grouping, __grouping_tmp))
            __testvalid = false;
        }


      if (__c == __eof)
        __err |= ios_base::eofbit;


      if (!__testvalid || !__temp_units.size())
        __err |= ios_base::failbit;
      else

        __temp_units.swap(__units);

      return __beg;
    }

  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 = __convert_from_v(__cs, __cs_size, "%.0Lf", __units,
                                   _S_c_locale);

      if (__len >= __cs_size)
        {
          __cs_size = __len + 1;
          __cs = static_cast<char*>(__builtin_alloca(__cs_size));
          __len = __convert_from_v(__cs, __cs_size, "%.0Lf", __units,
                                   _S_c_locale);
        }






      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                           * __cs_size));
      __ctype.widen(__cs, __cs + __len, __ws);
      const string_type __digits(__ws, __len);
      return this->do_put(__s, __intl, __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
    {
      typedef typename string_type::size_type size_type;
      typedef money_base::part part;

      const locale __loc = __io.getloc();
      const size_type __width = static_cast<size_type>(__io.width());


      typedef moneypunct<_CharT, true> __money_true;
      typedef moneypunct<_CharT, false> __money_false;
      const __money_true& __mpt = use_facet<__money_true>(__loc);
      const __money_false& __mpf = use_facet<__money_false>(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);



      const char_type* __beg = __digits.data();
      const char_type* __end = __beg + __digits.size();
      money_base::pattern __p;
      string_type __sign;
      if (*__beg != __ctype.widen('-'))
        {
          __p = __intl ? __mpt.pos_format() : __mpf.pos_format();
          __sign =__intl ? __mpt.positive_sign() : __mpf.positive_sign();
        }
      else
        {
          __p = __intl ? __mpt.neg_format() : __mpf.neg_format();
          __sign =__intl ? __mpt.negative_sign() : __mpf.negative_sign();
          ++__beg;
        }


      __end = __ctype.scan_not(ctype_base::digit, __beg, __end);
      if (__beg != __end)
        {



          string_type __res;
          string_type __value;
          const string_type __symbol = __intl ? __mpt.curr_symbol()
                                              : __mpf.curr_symbol();


          const int __frac = __intl ? __mpt.frac_digits()
                                    : __mpf.frac_digits();
          if (__frac > 0)
            {
              const char_type __d = __intl ? __mpt.decimal_point()
                                           : __mpf.decimal_point();
              if (__end - __beg >= __frac)
                {
                  __value = string_type(__end - __frac, __end);
                  __value.insert(__value.begin(), __d);
                  __end -= __frac;
                }
              else
                {

                  __value = string_type(__beg, __end);
                  int __paddec = __frac - (__end - __beg);
                  char_type __zero = __ctype.widen('0');
                  __value.insert(__value.begin(), __paddec, __zero);
                  __value.insert(__value.begin(), __d);
                  __beg = __end;
                }
            }



          if (__beg != __end)
            {
              const string __grouping = __intl ? __mpt.grouping()
                                               : __mpf.grouping();
              if (__grouping.size())
                {
                  const char_type __sep = __intl ? __mpt.thousands_sep()
                                                 : __mpf.thousands_sep();
                  const char* __gbeg = __grouping.c_str();
                  const char* __gend = __gbeg + __grouping.size();
                  const int __n = (__end - __beg) * 2;
                  _CharT* __ws2 =
                  static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n));
                  _CharT* __ws_end = __add_grouping(__ws2, __sep, __gbeg,
                                                    __gend, __beg, __end);
                  __value.insert(0, __ws2, __ws_end - __ws2);
                }
              else
                __value.insert(0, string_type(__beg, __end));
            }


          ios_base::fmtflags __f = __io.flags() & ios_base::adjustfield;
          size_type __len = __value.size() + __sign.size();
          __len += (__io.flags() & ios_base::showbase) ? __symbol.size() : 0;
          bool __testipad = __f == ios_base::internal && __len < __width;


          for (int __i = 0; __i < 4; ++__i)
            {
              part __which = static_cast<part>(__p.field[__i]);
              switch (__which)
                {
                case money_base::symbol:
                  if (__io.flags() & ios_base::showbase)
                    __res += __symbol;
                  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 += string_type(__width - __len, __fill);
                  else
                    __res += __ctype.widen(__fill);
                  break;
                case money_base::none:
                  if (__testipad)
                    __res += string_type(__width - __len, __fill);
                  break;
                }
            }


          if (__sign.size() > 1)
            __res += string_type(__sign.begin() + 1, __sign.end());


          __len = __res.size();
          if (__width > __len)
            {
              if (__f == ios_base::left)

                __res.append(__width - __len, __fill);
              else

                __res.insert(0, string_type(__width - __len, __fill));
              __len = __width;
            }


          __s = __write(__s, __res.c_str(), __len);
        }
      __io.width(0);
      return __s;
    }





  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>
    void
    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
    {
      locale __loc = __io.getloc();
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      size_t __len = char_traits<_CharT>::length(__format);

      for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
        {
          char __c = __format[__i];
          if (__c == '%')
            {

              __c = __format[++__i];
              char __mod = 0;
              int __mem = 0;
              if (__c == 'E' || __c == 'O')
                {
                  __mod = __c;
                  __c = __format[++__i];
                }
              switch (__c)
                {
                  const char* __cs;
                  _CharT __wcs[10];
                case 'a':

                  const char_type* __days1[7];
                  __tp._M_days_abbreviated(__days1);
                  _M_extract_name(__beg, __end, __tm->tm_wday, __days1, 7,
                                  __err);
                  break;
                case 'A':

                  const char_type* __days2[7];
                  __tp._M_days(__days2);
                  _M_extract_name(__beg, __end, __tm->tm_wday, __days2, 7,
                                  __err);
                  break;
                case 'h':
                case 'b':

                  const char_type* __months1[12];
                  __tp._M_months_abbreviated(__months1);
                  _M_extract_name(__beg, __end, __tm->tm_mon, __months1, 12,
                                  __err);
                  break;
                case 'B':

                  const char_type* __months2[12];
                  __tp._M_months(__months2);
                  _M_extract_name(__beg, __end, __tm->tm_mon, __months2, 12,
                                  __err);
                  break;
                case 'c':

                  const char_type* __dt[2];
                  __tp._M_date_time_formats(__dt);
                  _M_extract_via_format(__beg, __end, __io, __err, __tm,
                                        __dt[0]);
                  break;
                case 'd':

                  _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
                                 __ctype, __err);
                  break;
                case 'D':

                  __cs = "%m/%d/%y";
                  __ctype.widen(__cs, __cs + 9, __wcs);
                  _M_extract_via_format(__beg, __end, __io, __err, __tm,
                                        __wcs);
                  break;
                case 'H':

                  _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
                                 __ctype, __err);
                  break;
                case 'I':

                  _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
                                 __ctype, __err);
                  break;
                case 'm':

                  _M_extract_num(__beg, __end, __mem, 1, 12, 2, __ctype,
                                 __err);
                  if (!__err)
                    __tm->tm_mon = __mem - 1;
                  break;
                case 'M':

                  _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
                                 __ctype, __err);
                  break;
                case 'n':
                  if (__ctype.narrow(*__beg, 0) == '\n')
                    ++__beg;
                  else
                    __err |= ios_base::failbit;
                  break;
                case 'R':

                  __cs = "%H:%M";
                  __ctype.widen(__cs, __cs + 6, __wcs);
                  _M_extract_via_format(__beg, __end, __io, __err, __tm,
                                        __wcs);
                  break;
                case 'S':

                  _M_extract_num(__beg, __end, __tm->tm_sec, 0, 59, 2,
                                 __ctype, __err);
                  break;
                case 't':
                  if (__ctype.narrow(*__beg, 0) == '\t')
                    ++__beg;
                  else
                __err |= ios_base::failbit;
                  break;
                case 'T':

                  __cs = "%H:%M:%S";
                  __ctype.widen(__cs, __cs + 9, __wcs);
                  _M_extract_via_format(__beg, __end, __io, __err, __tm,
                                        __wcs);
                  break;
                case 'x':

                  const char_type* __dates[2];
                  __tp._M_date_formats(__dates);
                  _M_extract_via_format(__beg, __end, __io, __err, __tm,
                                        __dates[0]);
                  break;
                case 'X':

                  const char_type* __times[2];
                  __tp._M_time_formats(__times);
                  _M_extract_via_format(__beg, __end, __io, __err, __tm,
                                        __times[0]);
                  break;
                case 'y':

                  _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
                                 __ctype, __err);
                  break;
                case 'Y':

                  _M_extract_num(__beg, __end, __mem, 0,
                                 numeric_limits<int>::max(), 4,
                                 __ctype, __err);
                  if (!__err)
                    __tm->tm_year = __mem - 1900;
                  break;
                case 'Z':

                  if (__ctype.is(ctype_base::upper, *__beg))
                    {
                      int __tmp;
                      _M_extract_name(__beg, __end, __tmp,
                                      __timepunct<_CharT>::_S_timezones,
                                      14, __err);


                      char_type __c = *__beg;
                      if (!__err && __tmp == 0
                          && (__c == __ctype.widen('-')
                              || __c == __ctype.widen('+')))
                        {
                          _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
                                          __ctype, __err);
                          _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
                                          __ctype, __err);
                        }
                          }
                      else
                        __err |= ios_base::failbit;
                      break;
                    default:

                      __err |= ios_base::failbit;
                    }
                }
              else
                {

                  if (__c == __ctype.narrow(*__beg, 0))
                    ++__beg;
                  else
                    __err |= ios_base::failbit;
                }
        }
    }

  template<typename _CharT, typename _InIter>
    void
    time_get<_CharT, _InIter>::
    _M_extract_num(iter_type& __beg, iter_type& __end, int& __member,
                   int __min, int __max, size_t __len,
                   const ctype<_CharT>& __ctype,
                   ios_base::iostate& __err) const
    {
      size_t __i = 0;
      string __digits;
      bool __testvalid = true;
      char_type __c = *__beg;
      while (__beg != __end && __i < __len
             && __ctype.is(ctype_base::digit, __c))
        {
          __digits += __ctype.narrow(__c, 0);
          __c = *(++__beg);
          ++__i;
        }
      if (__i == __len)
        {
          int __value = atoi(__digits.c_str());
          if (__min <= __value && __value <= __max)
            __member = __value;
          else
            __testvalid = false;
        }
      else
        __testvalid = false;
      if (!__testvalid)
        __err |= ios_base::failbit;
    }



  template<typename _CharT, typename _InIter>
    void
    time_get<_CharT, _InIter>::
    _M_extract_name(iter_type& __beg, iter_type& __end, int& __member,
                    const _CharT** __names, size_t __indexlen,
                    ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      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;

      char_type __c = *__beg;

      for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
        if (__c == __names[__i1][0])
          __matches[__nmatches++] = __i1;

      while (__nmatches > 1)
        {

          size_t __minlen = 10;
          for (size_t __i2 = 0; __i2 < __nmatches; ++__i2)
            __minlen = min(__minlen,
                           __traits_type::length(__names[__matches[__i2]]));

          if (__pos < __minlen && __beg != __end)
            {
              ++__pos;
              __c = *(++__beg);
              for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
                {
                  __name = __names[__matches[__i3]];
                  if (__name[__pos] != __c)
                    __matches[__i3] = __matches[--__nmatches];
                }
            }
          else
            break;
        }

      if (__nmatches == 1)
        {

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

  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
    {
      _CharT __wcs[3];
      const char* __cs = "%X";
      locale __loc = __io.getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __ctype.widen(__cs, __cs + 3, __wcs);
      _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
      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
    {
      _CharT __wcs[3];
      const char* __cs = "%x";
      locale __loc = __io.getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __ctype.widen(__cs, __cs + 3, __wcs);
      _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
      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;
      locale __loc = __io.getloc();
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __days[7];
      __tp._M_days_abbreviated(__days);
      int __tmpwday;
      _M_extract_name(__beg, __end, __tmpwday, __days, 7, __err);







      if (!__err)
        {
          size_t __pos = __traits_type::length(__days[__tmpwday]);
          __tp._M_days(__days);
          const char_type* __name = __days[__tmpwday];
          if (__name[__pos] == *__beg)
            {

              const size_t __len = __traits_type::length(__name);
              while (__pos < __len && __beg != __end
                     && __name[__pos] == *__beg)
                ++__beg, ++__pos;
              if (__len != __pos)
                __err |= ios_base::failbit;
            }
          if (!__err)
            __tm->tm_wday = __tmpwday;
        }
      if (__beg == __end)
        __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      locale __loc = __io.getloc();
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __months[12];
      __tp._M_months_abbreviated(__months);
      int __tmpmon;
      _M_extract_name(__beg, __end, __tmpmon, __months, 12, __err);







      if (!__err)
        {
          size_t __pos = __traits_type::length(__months[__tmpmon]);
          __tp._M_months(__months);
          const char_type* __name = __months[__tmpmon];
          if (__name[__pos] == *__beg)
            {

              const size_t __len = __traits_type::length(__name);
              while (__pos < __len && __beg != __end
                     && __name[__pos] == *__beg)
                ++__beg, ++__pos;
              if (__len != __pos)
                __err |= ios_base::failbit;
            }
          if (!__err)
            __tm->tm_mon = __tmpmon;
        }

      if (__beg == __end)
        __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
                ios_base::iostate& __err, tm* __tm) const
    {
      locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      char_type __c = *__beg;
      size_t __i = 0;
      string __digits;
      while (__i < 4 && __beg != __end && __ctype.is(ctype_base::digit, __c))
        {
          __digits += __ctype.narrow(__c, 0);
          __c = *(++__beg);
          ++__i;
        }
      if (__i == 2 || __i == 4)
        {
          long __l;
          __convert_to_v(__digits.c_str(), __l, __err, _S_c_locale);
          if (!(__err & ios_base::failbit) && __l <= 2147483647)
            {
              __l = __i == 2 ? __l : __l - 1900;
              __tm->tm_year = static_cast<int>(__l);
            }
        }
      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, const tm* __tm,
        const _CharT* __beg, const _CharT* __end) const
    {
      locale __loc = __io.getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      while (__beg != __end)
        {
          char __c = __ctype.narrow(*__beg, 0);
          ++__beg;
          if (__c == '%')
            {
              char __format;
              char __mod = 0;
              size_t __len = 1;
              __c = __ctype.narrow(*__beg, 0);
              ++__beg;
              if (__c == 'E' || __c == 'O')
                {
                  __mod = __c;
                  __format = __ctype.narrow(*__beg, 0);
                  ++__beg;
                }
              else
                __format = __c;
              __s = this->do_put(__s, __io, _CharT(), __tm, __format, __mod);
            }
          else
            {
              *__s = __c;
              ++__s;
            }
        }
      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
    {
      locale __loc = __io.getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);



      const size_t __maxlen = 64;
      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 __write(__s, __res, char_traits<char_type>::length(__res));
    }



  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
    { return 0; }


  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
    { return 0; }

  template<typename _CharT>
    int
    collate<_CharT>::
    do_compare(const _CharT* __lo1, const _CharT* __hi1,
               const _CharT* __lo2, const _CharT* __hi2) const
    {


      const string_type __one(__lo1, __hi1);
      const string_type __two(__lo2, __hi2);

      const _CharT* __p = __one.c_str();
      const _CharT* __pend = __one.c_str() + __one.length();
      const _CharT* __q = __two.c_str();
      const _CharT* __qend = __two.c_str() + __two.length();




      for (;;)
        {
          int __res = _M_compare(__p, __q);
          if (__res)
            return __res;

          __p += char_traits<_CharT>::length(__p);
          __q += char_traits<_CharT>::length(__q);
          if (__p == __pend && __q == __qend)
            return 0;
          else if (__p == __pend)
            return -1;
          else if (__q == __qend)
            return 1;

          __p++;
          __q++;
        }
    }

 template<typename _CharT>
    typename collate<_CharT>::string_type
    collate<_CharT>::
    do_transform(const _CharT* __lo, const _CharT* __hi) const
    {

      string_type __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.c_str() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      string_type __ret;




      for (;;)
        {

          _CharT* __c =
            static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
          size_t __res = _M_transform(__c, __p, __len);


          if (__res >= __len)
            {
              __len = __res + 1;
              __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                          * __len));
              __res = _M_transform(__c, __p, __res + 1);
            }

          __ret.append(__c, __res);
          __p += char_traits<_CharT>::length(__p);
          if (__p == __pend)
            return __ret;

          __p++;
          __ret.push_back(_CharT());
        }
    }

 template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
        __val = *__lo + ((__val << 7) |
                       (__val >> (numeric_limits<unsigned long>::digits - 7)));
      return static_cast<long>(__val);
    }
# 2165 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
                                   _CharT* __news, const _CharT* __olds,
                                   const streamsize __newlen,
                                   const streamsize __oldlen, const bool __num)
    {
      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;


      if (__adjust == ios_base::left)
        {
          _Traits::copy(__news, const_cast<_CharT*>(__olds), __oldlen);
          _Traits::assign(__news + __oldlen, __plen, __fill);
          return;
        }

      size_t __mod = 0;
      if (__adjust == ios_base::internal && __num)
        {



          const locale& __loc = __io.getloc();
          const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
          const _CharT __minus = __ctype.widen('-');
          const _CharT __plus = __ctype.widen('+');
          const bool __testsign = _Traits::eq(__olds[0], __minus)
                                  || _Traits::eq(__olds[0], __plus);

          const bool __testhex = (_Traits::eq(__ctype.widen('0'), __olds[0])
                                  && __oldlen > 1
                                  && (_Traits::eq(__ctype.widen('x'), __olds[1])
                                      || _Traits::eq(__ctype.widen('X'),
                                                     __olds[1])));
          if (__testhex)
            {
              __news[0] = __olds[0];
              __news[1] = __olds[1];
              __mod = 2;
              __news += 2;
            }
          else if (__testsign)
            {
              __news[0] = __olds[0];
              __mod = 1;
              ++__news;
            }

        }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
                    __oldlen - __mod);
    }

  template<typename _CharT>
    bool
    __verify_grouping(const basic_string<_CharT>& __grouping,
                      basic_string<_CharT>& __grouping_tmp)
    {
      const size_t __n = __grouping_tmp.size() - 1;
      const size_t __min = std::min(__n, __grouping.size() - 1);
      size_t __i = __n;
      bool __test = true;




      for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
        __test = __grouping_tmp[__i] == __grouping[__j];
      for (; __i && __test; --__i)
        __test = __grouping_tmp[__i] == __grouping[__min];


      __test &= __grouping_tmp[0] <= __grouping[__min];
      return __test;
    }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
                   const char* __gbeg, const char* __gend,
                   const _CharT* __first, const _CharT* __last)
    {
      if (__last - __first > *__gbeg)
        {
          __s = __add_grouping(__s, __sep,
                               (__gbeg + 1 == __gend ? __gbeg : __gbeg + 1),
                               __gend, __first, __last - *__gbeg);
          __first = __last - *__gbeg;
          *__s++ = __sep;
        }
      do
        *__s++ = *__first++;
      while (__first != __last);
      return __s;
    }



  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
                     char __modl, _ValueT __v) const
      {



        char __fbuf[16];
        _S_format_int(__io, __fbuf, __mod, __modl);


        int __cs_size = 64;
        char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
        int __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
                                     _S_c_locale);

        if (__len >= __cs_size)
          {
            __cs_size = __len + 1;
            __cs = static_cast<char*>(__builtin_alloca(__cs_size));
            __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
                                     _S_c_locale);
          }






        return _M_widen_int(__s, __io, __fill, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    _M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs,
                   int __len) const
    {
      typedef char_traits<_CharT> __traits_type;


      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                           * __len));


      _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                            * __len * 2));
      __ctype.widen(__cs, __cs + __len, __ws);


      const _CharT* __p;
      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
      if (__p = __traits_type::find(__ws, __len, __ctype.widen('.')))
        __ws[__p - __ws] = __np.decimal_point();




      const string __grouping = __np.grouping();
      if (__grouping.size())
        {
          _CharT* __p2;
          int __declen = __p ? __p - __ws : __len;
          __p2 = __add_grouping(__ws2, __np.thousands_sep(),
                                __grouping.c_str(),
                                __grouping.c_str() + __grouping.size(),
                                __ws, __ws + __declen);
          int __newlen = __p2 - __ws2;


          if (__p)
            {
              __traits_type::copy(__p2, __p, __len - __declen);
              __newlen += __len - __declen;
            }


          __ws = __ws2;
          __len = __newlen;
        }

      return _M_insert(__s, __io, __fill, __ws, __len);
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    _M_widen_int(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs,
                 int __len) const
    {


      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                           * __len));


      _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                            * __len * 2));
      __ctype.widen(__cs, __cs + __len, __ws);


      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
      const string __grouping = __np.grouping();
      if (__grouping.size())
        {





          streamsize __off = 0;
          const ios_base::fmtflags __basefield = __io.flags()
                                                 & ios_base::basefield;
          if ((__io.flags() & ios_base::showbase) && __len > 1)
            if (__basefield == ios_base::oct)
              {
                __off = 1;
                *__ws2 = *__ws;
              }
            else if (__basefield == ios_base::hex)
              {
                __off = 2;
                *__ws2 = *__ws;
                *(__ws2 + 1) = *(__ws + 1);
              }
          _CharT* __p;
          __p = __add_grouping(__ws2 + __off, __np.thousands_sep(),
                               __grouping.c_str(),
                               __grouping.c_str() + __grouping.size(),
                               __ws + __off, __ws + __len);
          __len = __p - __ws2;

          __ws = __ws2;
        }
      return _M_insert(__s, __io, __fill, __ws, __len);
    }



  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    _M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws,
              int __len) const
    {
      typedef char_traits<_CharT> __traits_type;


      streamsize __w = __io.width();
      _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                            * __w));
      if (__w > static_cast<streamsize>(__len))
        {
          __pad<_CharT, __traits_type>::_S_pad(__io, __fill, __ws2, __ws,
                                               __w, __len, true);
          __len = static_cast<int>(__w);

          __ws = __ws2;
        }
      __io.width(0);



      return __write(__s, __ws, __len);
    }


  template<typename _CharT>
    __locale_cache<numpunct<_CharT> >::__locale_cache(const locale& __loc)
      : _M_truename(0), _M_falsename(0), _M_use_grouping(false),
        _M_grouping(0)
    {
      if (has_facet<numpunct<_CharT> >(__loc))
        {
          const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
          _M_decimal_point = __np.decimal_point();
          _M_thousands_sep = __np.thousands_sep();

          string_type __false = __np.falsename();
          _CharT* __falsename = new _CharT[__false.length() + 1];
          __false.copy(__falsename, __false.length());
          __falsename[__false.length()] = _CharT();
          _M_falsename = __falsename;

          string_type __true = __np.truename();
          _CharT* __truename = new _CharT[__true.length() + 1];
          __true.copy(__truename, __true.length());
          __truename[__true.length()] = _CharT();
          _M_truename = __truename;

          string __grouping = __np.grouping();
          char* __group = new char[__grouping.length() + 1];
          __grouping.copy(__group, __grouping.length());
          __group[__grouping.length()] = 0;
          _M_grouping = __group;

          _M_use_grouping = __grouping.length() != 0
            && __grouping.data()[0] != 0;
        }

      if (has_facet<ctype<_CharT> >(__loc))
        {
          const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
          __ct.widen(__num_base::_S_atoms_out,
                     __num_base::_S_atoms_out + __num_base::_S_end,
                     _M_atoms_out);
        }
    }



  template<typename _CharT>
    __locale_cache<numpunct<_CharT> >::
    __locale_cache(const locale& __loc, bool)
    {

      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
      _M_thousands_sep = __np._M_thousands_sep;
      _M_decimal_point = __np._M_decimal_point;
      _M_falsename = __np._M_falsename;
      _M_truename = __np._M_truename;
      _M_grouping = __np._M_grouping;
      _M_use_grouping = false;

      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
      __ct.widen(__num_base::_S_atoms_out,
                 __num_base::_S_atoms_out + __num_base::_S_end,
                 _M_atoms_out);
    }





  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class money_get<char>;
  extern template class money_put<char>;
  extern template class numpunct<char>;
  extern template class numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;
  extern template class ctype_byname<char>;
  extern template class codecvt_byname<char, char, mbstate_t>;
  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

  extern template
    const numpunct<char>&
    use_facet<numpunct<char> >(const locale&);

  extern template
    const num_put<char>&
    use_facet<num_put<char> >(const locale&);

  extern template
    const num_get<char>&
    use_facet<num_get<char> >(const locale&);

  extern template
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<collate<char> >(const locale&);

  extern template
    bool
    has_facet<numpunct<char> >(const locale&);

  extern template
    bool
    has_facet<num_put<char> >(const locale&);

  extern template
    bool
    has_facet<num_get<char> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class money_get<wchar_t>;
  extern template class money_put<wchar_t>;
  extern template class numpunct<wchar_t>;
  extern template class numpunct_byname<wchar_t>;
  extern template class num_get<wchar_t>;
  extern template class num_put<wchar_t>;
  extern template class __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;
  extern template class ctype_byname<wchar_t>;
  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);

  extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

  extern template
    const numpunct<wchar_t>&
    use_facet<numpunct<wchar_t> >(const locale&);

  extern template
    const num_put<wchar_t>&
    use_facet<num_put<wchar_t> >(const locale&);

  extern template
    const num_get<wchar_t>&
    use_facet<num_get<wchar_t> >(const locale&);

  extern template
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

 extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<numpunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);


}
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/locale" 2 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/ostream.tcc" 2 3

namespace std
{
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT, _Traits>& __os)
    : _M_os(__os)
    {

      if (__os.tie() && __os.good())
        __os.tie()->flush();

      if (__os.good())
        _M_ok = true;
      else
        {
          _M_ok = false;
          __os.setstate(ios_base::failbit);
        }
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ostream_type& (*__pf)(__ostream_type&))
    {



      return __pf(*this);
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ios_type& (*__pf)(__ios_type&))
    {



      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(ios_base& (*__pf)(ios_base&))
    {



      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(bool __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if (__np.put(*this, *this, this->fill(), __n).failed())
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              bool __b = false;
              char_type __c = this->fill();
              ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
                {
                  unsigned long __l = static_cast<unsigned long>(__n);
                  __b = __np.put(*this, *this, __c, __l).failed();
                }
              else
                __b = __np.put(*this, *this, __c, __n).failed();
              if (__b)
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(unsigned long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if (__np.put(*this, *this, this->fill(), __n).failed())
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(long long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              bool __b = false;
              char_type __c = this->fill();
              ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
                {
                  unsigned long long __l;
                  __l = static_cast<unsigned long long>(__n);
                  __b = __np.put(*this, *this, __c, __l).failed();
                }
              else
                __b = __np.put(*this, *this, __c, __n).failed();
              if (__b)
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(unsigned long long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if (__np.put(*this, *this, this->fill(), __n).failed())
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if (__np.put(*this, *this, this->fill(), __n).failed())
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(long double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if (__np.put(*this, *this, this->fill(), __n).failed())
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(const void* __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumput);
              const __numput_type& __np = *this->_M_fnumput;
              if (__np.put(*this, *this, this->fill(), __n).failed())
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this);
      if (__cerb && __sbin)
        {
          try
            {
              if (!__copy_streambufs(*this, __sbin, this->rdbuf()))
                __err |= ios_base::failbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::failbit); }
        }
      else if (!__sbin)
        __err |= ios_base::badbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::put(char_type __c)
    {






      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              int_type __put = this->rdbuf()->sputc(__c);
              if (traits_type::eq_int_type(__put, traits_type::eof()))
                __err |= ios_base::badbit;
            }
          catch (...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::write(const _CharT* __s, streamsize __n)
    {







      sentry __cerb(*this);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              streamsize __put = this->rdbuf()->sputn(__s, __n);
              if (__put != __n)
                __err |= ios_base::badbit;
            }
          catch (...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::flush()
    {



      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
        {
          if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
            __err |= ios_base::badbit;
        }
      catch(...)
        { this->_M_setstate(ios_base::badbit); }
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::tellp()
    {
      pos_type __ret = pos_type(-1);
      try
        {
          if (!this->fail())
            __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
        }
      catch(...)
        { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
        {
          if (!this->fail())
            {


              pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out);


              if (__p == pos_type(off_type(-1)))
                __err |= ios_base::failbit;
            }
        }
      catch(...)
        { this->_M_setstate(ios_base::badbit); }
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __dir)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
        {
          if (!this->fail())
            {


              pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
                                                       ios_base::out);


              if (__p == pos_type(off_type(-1)))
                __err |= ios_base::failbit;
            }
        }
      catch(...)
        { this->_M_setstate(ios_base::badbit); }
      if (__err)
        this->setstate(__err);
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          try
            {
              const streamsize __w = __out.width() > 0 ? __out.width() : 0;
              _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__w + 1)));
              __pads[0] = __c;
              streamsize __len = 1;
              if (__w > __len)
                {
                  __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
                                                 &__c, __w, __len, false);
                  __len = __w;
                }
              __out.write(__pads, __len);
              __out.width(0);
            }
          catch(...)
            { __out._M_setstate(ios_base::badbit); }
        }
      return __out;
    }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          try
            {
              const streamsize __w = __out.width() > 0 ? __out.width() : 0;
              char* __pads = static_cast<char*>(__builtin_alloca(__w + 1));
              __pads[0] = __c;
              streamsize __len = 1;
              if (__w > __len)
                {
                  __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
                                               &__c, __w, __len, false);
                  __len = __w;
                }
              __out.write(__pads, __len);
              __out.width(0);
            }
          catch(...)
            { __out._M_setstate(ios_base::badbit); }
        }
      return __out;
     }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
        {
          try
            {
              const streamsize __w = __out.width() > 0 ? __out.width() : 0;
              _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
              streamsize __len = static_cast<streamsize>(_Traits::length(__s));
              if (__w > __len)
                {
                  __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
                                                 __s, __w, __len, false);
                  __s = __pads;
                  __len = __w;
                }
              __out.write(__s, __len);
              __out.width(0);
            }
          catch(...)
            { __out._M_setstate(ios_base::badbit); }
        }
      else if (!__s)
        __out.setstate(ios_base::badbit);
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;



      typedef char_traits<char> __traits_type;

      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
        {
          size_t __clen = __traits_type::length(__s);
          _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__clen + 1)));
          for (size_t __i = 0; __i < __clen; ++__i)
            __ws[__i] = __out.widen(__s[__i]);
          _CharT* __str = __ws;

          try
            {
              streamsize __len = static_cast<streamsize>(__clen);
              const streamsize __w = __out.width() > 0 ? __out.width() : 0;
              _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));

              if (__w > __len)
                {
                  __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
                                                 __ws, __w, __len, false);
                  __str = __pads;
                  __len = __w;
                }
              __out.write(__str, __len);
              __out.width(0);
            }
          catch(...)
            { __out._M_setstate(ios_base::badbit); }
        }
      else if (!__s)
        __out.setstate(ios_base::badbit);
      return __out;
    }


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
        {
          try
            {
              const streamsize __w = __out.width() > 0 ? __out.width() : 0;
              char* __pads = static_cast<char*>(__builtin_alloca(__w));
              streamsize __len = static_cast<streamsize>(_Traits::length(__s));

              if (__w > __len)
                {
                  __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
                                                 __s, __w, __len, false);
                  __s = __pads;
                  __len = __w;
                }
              __out.write(__s, __len);
              __out.width(0);
            }
          catch(...)
            { __out._M_setstate(ios_base::badbit); }
        }
      else if (!__s)
        __out.setstate(ios_base::badbit);
      return __out;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out,
               const basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          const _CharT* __s = __str.data();
          const streamsize __w = __out.width() > 0 ? __out.width() : 0;
          _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
          streamsize __len = static_cast<streamsize>(__str.size());



          if (__w > __len)
            {
              __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads, __s,
                                             __w, __len, false);
              __s = __pads;
              __len = __w;
            }
          streamsize __res = __out.rdbuf()->sputn(__s, __len);
          __out.width(0);
          if (__res != __len)
            __out.setstate(ios_base::failbit);
        }
      return __out;
    }





  extern template class basic_ostream<char>;
  extern template ostream& endl(ostream&);
  extern template ostream& ends(ostream&);
  extern template ostream& flush(ostream&);
  extern template ostream& operator<<(ostream&, char);
  extern template ostream& operator<<(ostream&, unsigned char);
  extern template ostream& operator<<(ostream&, signed char);
  extern template ostream& operator<<(ostream&, const char*);
  extern template ostream& operator<<(ostream&, const unsigned char*);
  extern template ostream& operator<<(ostream&, const signed char*);


  extern template class basic_ostream<wchar_t>;
  extern template wostream& endl(wostream&);
  extern template wostream& ends(wostream&);
  extern template wostream& flush(wostream&);
  extern template wostream& operator<<(wostream&, wchar_t);
  extern template wostream& operator<<(wostream&, char);
  extern template wostream& operator<<(wostream&, const wchar_t*);
  extern template wostream& operator<<(wostream&, const char*);


}
# 536 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ostream" 2 3
# 46 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iostream" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
#define _CPP_ISTREAM 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3




namespace std
{
# 57 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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 istreambuf_iterator<_CharT, _Traits> __istreambuf_iter;
      typedef num_get<_CharT, __istreambuf_iter> __numget_type;
      typedef ctype<_CharT> __ctype_type;

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2&);

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

    protected:







      streamsize _M_gcount;

    public:
# 103 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      explicit
      basic_istream(__streambuf_type* __sb)
      {
        this->init(__sb);
        _M_gcount = streamsize(0);
      }






      virtual
      ~basic_istream()
      { _M_gcount = streamsize(0); }


      class sentry;
      friend class sentry;
# 133 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&));

      __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&));

      __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&));
# 171 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      operator>>(bool& __n);

      __istream_type&
      operator>>(short& __n);

      __istream_type&
      operator>>(unsigned short& __n);

      __istream_type&
      operator>>(int& __n);

      __istream_type&
      operator>>(unsigned int& __n);

      __istream_type&
      operator>>(long& __n);

      __istream_type&
      operator>>(unsigned long& __n);


      __istream_type&
      operator>>(long long& __n);

      __istream_type&
      operator>>(unsigned long long& __n);


      __istream_type&
      operator>>(float& __f);

      __istream_type&
      operator>>(double& __f);

      __istream_type&
      operator>>(long double& __f);

      __istream_type&
      operator>>(void*& __p);
# 232 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 242 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      inline streamsize
      gcount() const
      { return _M_gcount; }
# 274 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      int_type
      get();
# 288 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      get(char_type& __c);
# 315 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 326 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      inline __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 349 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 359 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      inline __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 388 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 399 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      inline __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 418 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      ignore(streamsize __n = 1, int_type __delim = traits_type::eof());
# 429 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      int_type
      peek();
# 447 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 466 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 482 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      putback(char_type __c);
# 497 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      unget();
# 515 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      int
      sync();
# 529 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      pos_type
      tellg();
# 544 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      seekg(pos_type);
# 560 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      __istream_type&
      seekg(off_type, ios_base::seekdir);

    };
# 576 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
# 608 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 618 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
      operator bool() { return _M_ok; }

    private:
      bool _M_ok;
    };
# 637 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }
# 678 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);

  template<class _Traits>
    basic_istream<char,_Traits>&
    operator>>(basic_istream<char,_Traits>& __in, unsigned char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }

  template<class _Traits>
    basic_istream<char,_Traits>&
    operator>>(basic_istream<char,_Traits>& __in, signed char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }
# 700 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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() { }
    };
# 759 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
}


#define export 


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/istream.tcc" 1 3
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/istream.tcc" 3
       
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/istream.tcc" 3




namespace std
{
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>::sentry::
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      if (__in.good())
        {
          if (__in.tie())
            __in.tie()->flush();
          if (!__noskipws && (__in.flags() & ios_base::skipws))
            {
              const __int_type __eof = traits_type::eof();
              __streambuf_type* __sb = __in.rdbuf();
              __int_type __c = __sb->sgetc();

              __in._M_check_facet(__in._M_fctype);
              const __ctype_type& __ct = *__in._M_fctype;
              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
        {
          _M_ok = false;
          __err |= ios_base::failbit;
          __in.setstate(__err);
        }
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__istream_type& (*__pf)(__istream_type&))
    { return __pf(*this); }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__ios_type& (*__pf)(__ios_type&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(ios_base& (*__pf)(ios_base&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(bool& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(short& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              long __l;
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __l);


              if (!(__err & ios_base::failbit)
                  && (numeric_limits<short>::min() <= __l
                      && __l <= numeric_limits<short>::max()))
                __n = __l;
              else
                __err |= ios_base::failbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned short& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(int& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              long __l;
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __l);


              if (!(__err & ios_base::failbit)
                  && (numeric_limits<int>::min() <= __l
                      && __l <= numeric_limits<int>::max()))
                __n = __l;
              else
                __err |= ios_base::failbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned int& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned long long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(float& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(void*& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_check_facet(this->_M_fnumget);
              const __numget_type& __ng = *this->_M_fnumget;
              __ng.get(*this, 0, *this, __err, __n);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__streambuf_type* __sbout)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, false);
      if (__cerb && __sbout)
        {
          try
            {
              if (!__copy_streambufs(*this, this->rdbuf(), __sbout))
                __err |= ios_base::failbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::failbit); }
        }
      else if (!__sbout)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    get(void)
    {
      const int_type __eof = traits_type::eof();
      int_type __c = __eof;
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              __c = this->rdbuf()->sbumpc();

              if (!traits_type::eq_int_type(__c, __eof))
                _M_gcount = 1;
              else
                __err |= ios_base::eofbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type& __c)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              int_type __cb = this->rdbuf()->sbumpc();

              if (!traits_type::eq_int_type(__cb, traits_type::eof()))
                {
                  _M_gcount = 1;
                  __c = traits_type::to_char_type(__cb);
                }
              else
                __err |= ios_base::eofbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();

              while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
                  *__s++ = traits_type::to_char_type(__c);
                  __c = __sb->snextc();
                  ++_M_gcount;
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }
      *__s = char_type();
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(__streambuf_type& __sb, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __this_sb = this->rdbuf();
              int_type __c = __this_sb->sgetc();
              char_type __c2 = traits_type::to_char_type(__c);

              while (!traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim)
                     && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
                {
                  ++_M_gcount;
                  __c = __this_sb->snextc();
                  __c2 = traits_type::to_char_type(__c);
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();

              while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
                  *__s++ = traits_type::to_char_type(__c);
                  __c = __sb->snextc();
                  ++_M_gcount;
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
              else
                {
                  if (traits_type::eq_int_type(__c, __idelim))
                    {
                      __sb->sbumpc();
                      ++_M_gcount;
                    }
                  else
                    __err |= ios_base::failbit;
                }
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }
      *__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(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;

              __n = min(__n, numeric_limits<streamsize>::max());
              while (_M_gcount < __n
                     && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
                {
                  ++_M_gcount;
                  if (traits_type::eq_int_type(__c, __delim))
                    break;
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              __c = this->rdbuf()->sgetc();
              if (traits_type::eq_int_type(__c, traits_type::eof()))
                __err |= ios_base::eofbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
       return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              _M_gcount = this->rdbuf()->sgetn(__s, __n);
              if (_M_gcount != __n)
                __err |= (ios_base::eofbit | ios_base::failbit);
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {

              streamsize __num = this->rdbuf()->in_avail();
              if (__num >= 0)
                {
                  __num = min(__num, __n);
                  if (__num)
                    _M_gcount = this->rdbuf()->sgetn(__s, __num);
                }
              else
                __err |= ios_base::eofbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {


      _M_gcount = 0;

      sentry __cerb(*this, true);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              if (!__sb
                  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {


      _M_gcount = 0;

      sentry __cerb(*this, true);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              if (!__sb
                  || traits_type::eq_int_type(__sb->sungetc(), __eof))
                __err |= ios_base::badbit;
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {


      int __ret = -1;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              __streambuf_type* __sb = this->rdbuf();
              if (__sb)
                {
                  if (__sb->pubsync() == -1)
                    __err |= ios_base::badbit;
                  else
                    __ret = 0;
                }
            }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {


      pos_type __ret = pos_type(-1);
      try
        {
          if (!this->fail())
            __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
        }
      catch(...)
        { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {


      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
        {
          if (!this->fail())
            {

              pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::in);


              if (__p == pos_type(off_type(-1)))
                __err |= ios_base::failbit;
            }
        }
      catch(...)
        { this->_M_setstate(ios_base::badbit); }
      if (__err)
        this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {


      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
        {
          if (!this->fail())
            {

              pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
                                                       ios_base::in);


              if (__p == pos_type(off_type(-1)))
                __err |= ios_base::failbit;
            }
        }
      catch(...)
        { this->_M_setstate(ios_base::badbit); }
      if (__err)
        this->setstate(__err);
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
          try
            {
              typename __istream_type::int_type __cb = __in.rdbuf()->sbumpc();
              if (!_Traits::eq_int_type(__cb, _Traits::eof()))
                __c = _Traits::to_char_type(__cb);
              else
                __err |= (ios_base::eofbit | ios_base::failbit);
            }
          catch(...)
            { __in._M_setstate(ios_base::badbit); }
          if (__err)
            __in.setstate(__err);
        }
      return __in;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename _Traits::int_type int_type;
      typedef _CharT char_type;
      typedef ctype<_CharT> __ctype_type;

      streamsize __extracted = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
        {
          try
            {

              streamsize __num = __in.width();
              if (__num <= 0)
                __num = numeric_limits<streamsize>::max();

              const __ctype_type& __ctype = 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)
                     && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
                {
                  *__s++ = _Traits::to_char_type(__c);
                  ++__extracted;
                  __c = __sb->snextc();
                }
              if (_Traits::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;



              *__s = char_type();

              __in.width(0);
            }
          catch(...)
            { __in._M_setstate(ios_base::badbit); }
        }
      if (!__extracted)
        __err |= ios_base::failbit;
      if (__err)
        __in.setstate(__err);
      return __in;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT,_Traits>&
    ws(basic_istream<_CharT,_Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename __istream_type::int_type __int_type;

      const __ctype_type& __ctype = 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)
             && __ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
        __c = __sb->snextc();

       if (_Traits::eq_int_type(__c, __eof))
         __in.setstate(ios_base::eofbit);
      return __in;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
               basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
        {
          try
            {
              __str.erase();
              streamsize __w = __in.width();
              __size_type __n;
              __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();

              const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
              const __int_type __eof = _Traits::eof();
              __streambuf_type* __sb = __in.rdbuf();
              __int_type __c = __sb->sgetc();

              while (__extracted < __n
                     && !_Traits::eq_int_type(__c, __eof)
                     && !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
                {
                  __str += _Traits::to_char_type(__c);
                  ++__extracted;
                  __c = __sb->snextc();
                }
              if (_Traits::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
              __in.width(0);
            }
          catch(...)
            {



              __in._M_setstate(ios_base::badbit);
            }
        }

      if (!__extracted)
        __err |= ios_base::failbit;
      if (__err)
        __in.setstate(__err);
      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
            basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      bool __testdelim = false;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
        {
          try
            {
              __str.erase();
              __int_type __idelim = _Traits::to_int_type(__delim);
              __streambuf_type* __sb = __in.rdbuf();
              __int_type __c = __sb->sbumpc();
              const __int_type __eof = _Traits::eof();
              __testdelim = _Traits::eq_int_type(__c, __idelim);

              while (!_Traits::eq_int_type(__c, __eof) && !__testdelim
                     && __extracted < __n)
                {
                  __str += _Traits::to_char_type(__c);
                  ++__extracted;
                  __c = __sb->sbumpc();
                  __testdelim = _Traits::eq_int_type(__c, __idelim);
                }
              if (_Traits::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
          catch(...)
            {



              __in._M_setstate(ios_base::badbit);
            }
        }
      if ((!__extracted && !__testdelim) || __extracted == __n)
        __err |= ios_base::failbit;
      if (__err)
        __in.setstate(__err);
      return __in;
    }

  template<class _CharT, class _Traits, class _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
            basic_string<_CharT,_Traits,_Alloc>& __str)
    { return getline(__in, __str, __in.widen('\n')); }





  extern template class basic_istream<char>;
  extern template istream& ws(istream&);
  extern template istream& operator>>(istream&, char&);
  extern template istream& operator>>(istream&, char*);
  extern template istream& operator>>(istream&, unsigned char&);
  extern template istream& operator>>(istream&, signed char&);
  extern template istream& operator>>(istream&, unsigned char*);
  extern template istream& operator>>(istream&, signed char*);


  extern template class basic_istream<wchar_t>;
  extern template wistream& ws(wistream&);
  extern template wistream& operator>>(wistream&, wchar_t&);
  extern template wistream& operator>>(wistream&, wchar_t*);


}
# 769 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/istream" 2 3
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iostream" 2 3

namespace std
{
# 63 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h" 2


# 1 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointer.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointer.h"
#define __itkSmartPointer_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h" 1
# 31 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define __itkMacro_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkWin32Header.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkWin32Header.h"
#define __itkWIN32Header_h 

# 1 "/tmp/installed/include/InsightToolkit/itkConfigure.h" 1
# 13 "/tmp/installed/include/InsightToolkit/itkConfigure.h"
#define CMAKE_USE_PTHREADS 

#define ITK_USE_PTHREADS 
# 33 "/tmp/installed/include/InsightToolkit/itkConfigure.h"
#define ITK_BUILD_SHARED_LIBS 

#define ITKDLL 
# 45 "/tmp/installed/include/InsightToolkit/itkConfigure.h"
#define ITK_VERSION_MAJOR 1
#define ITK_VERSION_MINOR 9
#define ITK_VERSION_PATCH 0
#define ITK_VERSION_STRING "1.9"
# 24 "/tmp/installed/include/InsightToolkit/Common/itkWin32Header.h" 2
# 79 "/tmp/installed/include/InsightToolkit/Common/itkWin32Header.h"
#define ITK_TYPENAME typename



#define ITK_EXPORT 
# 93 "/tmp/installed/include/InsightToolkit/Common/itkWin32Header.h"
#define ITKCommon_EXPORT 
# 34 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h" 2
# 1 "/tmp/installed/include/InsightToolkit/itkConfigure.h" 1
# 13 "/tmp/installed/include/InsightToolkit/itkConfigure.h"
#define CMAKE_USE_PTHREADS 

#define ITK_USE_PTHREADS 
# 33 "/tmp/installed/include/InsightToolkit/itkConfigure.h"
#define ITK_BUILD_SHARED_LIBS 

#define ITKDLL 
# 45 "/tmp/installed/include/InsightToolkit/itkConfigure.h"
#define ITK_VERSION_MAJOR 1
#define ITK_VERSION_MINOR 9
#define ITK_VERSION_PATCH 0
#define ITK_VERSION_STRING "1.9"
# 35 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h" 2





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
#define _CPP_SSTREAM 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3




namespace std
{
# 61 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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:






      __string_type _M_string;

    public:
# 105 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_string()
      { _M_stringbuf_init(__mode); }
# 118 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_stringbuf(const __string_type& __str,
                      ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_string(__str.data(), __str.size())
      { _M_stringbuf_init(__mode); }
# 133 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      __string_type
      str() const
      {
        if (_M_mode & ios_base::out)
          {




            __size_type __len = _M_string.size();
            if (_M_out_end > _M_out_beg)
              __len = max(__size_type(_M_out_end - _M_out_beg), __len);
            return __string_type(_M_out_beg, _M_out_beg + __len);
          }
        else
          return _M_string;
      }
# 158 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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_buf_size = _M_string.size();





        _M_buf_size_opt = 512;
        _M_mode = __mode;
        if (_M_mode & (ios_base::ate | ios_base::app))
          _M_really_sync(0, _M_buf_size);
        else
          _M_really_sync(0, 0);
      }



      virtual int_type
      underflow()
      {
        if (_M_in_cur && _M_in_cur < _M_in_end)
          return traits_type::to_int_type(*gptr());
        else
          return traits_type::eof();
      }


      virtual int_type
      pbackfail(int_type __c = traits_type::eof());


      virtual int_type
      overflow(int_type __c = traits_type::eof());
# 225 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n)
      {
        if (__s && __n)
          {
            _M_string = __string_type(__s, __n);
            _M_really_sync(0, 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);
# 257 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      virtual int
      _M_really_sync(__size_type __i, __size_type __o)
      {
        char_type* __base = const_cast<char_type*>(_M_string.data());
        bool __testin = _M_mode & ios_base::in;
        bool __testout = _M_mode & ios_base::out;
        __size_type __len = _M_string.size();

        _M_buf = __base;
        if (__testin)
            this->setg(__base, __base + __i, __base + __len);
        if (__testout)
          {
            this->setp(__base, __base + __len);
            _M_out_cur += __o;
          }
        return 0;
      }
    };
# 287 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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:
# 331 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode = ios_base::in)
      : __istream_type(__null), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 351 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_istringstream(const __string_type& __str,
                          ios_base::openmode __mode = ios_base::in)
      : __istream_type(__null), _M_stringbuf(__str, __mode | ios_base::in)
      { this->init(&_M_stringbuf); }







      ~basic_istringstream()
      { }
# 373 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
    };
# 406 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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:
# 450 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
      : __ostream_type(__null), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 470 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_ostringstream(const __string_type& __str,
                          ios_base::openmode __mode = ios_base::out)
      : __ostream_type(__null), _M_stringbuf(__str, __mode | ios_base::out)
      { this->init(&_M_stringbuf); }







      ~basic_ostringstream()
      { }
# 492 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
    };
# 525 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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:
# 567 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(__null), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 585 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 3
      explicit
      basic_stringstream(const __string_type& __str,
                         ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(__null), _M_stringbuf(__str, __m)
      { this->init(&_M_stringbuf); }







      ~basic_stringstream()
      { }
# 607 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
    };
}


#define export 


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/sstream.tcc" 1 3
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/sstream.tcc" 3
#define _CPP_BITS_SSTREAM_TCC 1

       
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/sstream.tcc" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/sstream.tcc" 2 3

namespace std
{
  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    pbackfail(int_type __c)
    {
      int_type __ret = traits_type::eof();
      bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
      bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;



      if (__testpos)
        {
          if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])
              && !__testeof)
            {
              --_M_in_cur;
              __ret = __c;
            }
          else if (!__testeof)
            {
              --_M_in_cur;
              *_M_in_cur = traits_type::to_char_type(__c);
              __ret = __c;
            }
          else if (__testeof)
            {
              --_M_in_cur;
              __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)
    {
      int_type __ret = traits_type::eof();
      bool __testeof = traits_type::eq_int_type(__c, __ret);
      bool __testwrite = _M_out_cur < _M_buf + _M_buf_size;
      bool __testout = _M_mode & ios_base::out;



      if (__testout)
        {
          if (!__testeof)
            {
              __size_type __len = max(_M_buf_size, _M_buf_size_opt);
              __len *= 2;

              if (__testwrite)
                __ret = this->sputc(traits_type::to_char_type(__c));
              else if (__len <= _M_string.max_size())
                {

                  _M_string = this->str();
                  _M_string.reserve(__len);
                  _M_buf_size = __len;
                  _M_really_sync(_M_in_cur - _M_in_beg,
                                 _M_out_cur - _M_out_beg);
                  *_M_out_cur = traits_type::to_char_type(__c);
                  _M_out_cur_move(1);
                  __ret = __c;
                }
            }
          else
            __ret = traits_type::not_eof(__c);
        }
      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 & _M_mode & __mode) != 0;
      bool __testout = (ios_base::out & _M_mode & __mode) != 0;
      bool __testboth = __testin && __testout && __way != ios_base::cur;
      __testin &= !(__mode & ios_base::out);
      __testout &= !(__mode & ios_base::in);

      if (_M_buf_size && (__testin || __testout || __testboth))
        {
          char_type* __beg = _M_buf;
          char_type* __curi = __null;
          char_type* __curo = __null;
          char_type* __endi = __null;
          char_type* __endo = __null;

          if (__testin || __testboth)
            {
              __curi = this->gptr();
              __endi = this->egptr();
            }
          if (__testout || __testboth)
            {
              __curo = this->pptr();
              __endo = this->epptr();
            }

          off_type __newoffi = 0;
          off_type __newoffo = 0;
          if (__way == ios_base::cur)
            {
              __newoffi = __curi - __beg;
              __newoffo = __curo - __beg;
            }
          else if (__way == ios_base::end)
            {
              __newoffi = __endi - __beg;
              __newoffo = __endo - __beg;
            }

          if ((__testin || __testboth)
              && __newoffi + __off >= 0 && __endi - __beg >= __newoffi + __off)
            {
              _M_in_cur = __beg + __newoffi + __off;
              __ret = pos_type(__newoffi);
            }
          if ((__testout || __testboth)
              && __newoffo + __off >= 0 && __endo - __beg >= __newoffo + __off)
            {
              _M_out_cur_move(__newoffo + __off - (_M_out_cur - __beg));
              __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));

      if (_M_buf_size)
        {
          off_type __pos = __sp;
          char_type* __beg = __null;
          char_type* __end = __null;
          bool __testin = (ios_base::in & _M_mode & __mode) != 0;
          bool __testout = (ios_base::out & _M_mode & __mode) != 0;
          bool __testboth = __testin && __testout;
          __testin &= !(__mode & ios_base::out);
          __testout &= !(__mode & ios_base::in);


          bool __testposi = false;
          bool __testposo = false;
          if (__testin || __testboth)
            {
              __beg = this->eback();
              __end = this->egptr();
              if (0 <= __pos && __pos <= __end - __beg)
                __testposi = true;
            }
          if (__testout || __testboth)
            {
              __beg = this->pbase();
              __end = _M_buf + _M_buf_size;
              if (0 <= __pos && __pos <= __end - __beg)
                __testposo = true;
            }
          if (__testposi || __testposo)
            {
              if (__testposi)
                _M_in_cur = _M_in_beg + __pos;
              if (__testposo)
                _M_out_cur_move((__pos) - (_M_out_cur - __beg));
              __ret = pos_type(off_type(__pos));
            }
        }
      return __ret;
    }
# 241 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/sstream.tcc" 3
}
# 636 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/sstream" 2 3
# 41 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h" 2
# 53 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
namespace itk
{
}



#define itkNotUsed(x) 
# 92 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkStaticConstMacro(name,type,value) static const type name = value





#define itkGetStaticConstMacro(name) (Self::name)



#define itkSetInputMacro(name,type,number) virtual void Set ##name ##Input(const type *_arg) { itkDebugMacro("setting input " #name " to " << _arg); if (_arg != static_cast<type *>(this->ProcessObject::GetInput( number ))) { this->ProcessObject::SetNthInput( number, const_cast<type *>(_arg) ); this->Modified(); } } virtual void SetInput ##number(const type *_arg) { itkDebugMacro("setting input " #number " to " << _arg); if (_arg != static_cast<type *>(this->ProcessObject::GetInput( number ))) { this->ProcessObject::SetNthInput( number, const_cast<type *>(_arg) ); this->Modified(); } }
# 124 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetInputMacro(name,type,number) virtual const type * Get ##name ##Input() const { itkDebugMacro("returning input " << #name " of " << static_cast<const type *>(this->ProcessObject::GetInput( number )) ); return static_cast<const type *>(this->ProcessObject::GetInput( number )); } virtual const type * GetInput ##number() const { itkDebugMacro("returning input " << #number " of " << static_cast<const type *>(this->ProcessObject::GetInput( number )) ); return static_cast<const type *>(this->ProcessObject::GetInput( number )); }
# 138 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkSetMacro(name,type) virtual void Set ##name (const type _arg) { itkDebugMacro("setting " #name " to " << _arg); if (this->m_ ##name != _arg) { this->m_ ##name = _arg; this->Modified(); } }
# 150 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetMacro(name,type) virtual type Get ##name () { itkDebugMacro("returning " << #name " of " << this->m_ ##name ); return this->m_ ##name; }
# 160 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetConstMacro(name,type) virtual type Get ##name () const { itkDebugMacro("returning " << #name " of " << this->m_ ##name ); return this->m_ ##name; }
# 171 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetConstReferenceMacro(name,type) virtual const type & Get ##name () const { itkDebugMacro("returning " << #name " of " << this->m_ ##name ); return this->m_ ##name; }
# 181 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkSetStringMacro(name) virtual void Set ##name (const char* _arg) { if ( _arg && (_arg == this->m_ ##name) ) { return;} if (_arg) { this->m_ ##name = _arg; } else { this->m_ ##name = ""; } this->Modified(); }
# 200 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetStringMacro(name) virtual const char* Get ##name () const { return this->m_ ##name.c_str(); }
# 209 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkSetClampMacro(name,type,min,max) virtual void Set ##name (type _arg) { itkDebugMacro("setting " << #name " to " << _arg ); if (this->m_ ##name != (_arg<min?min:(_arg>max?max:_arg))) { this->m_ ##name = (_arg<min?min:(_arg>max?max:_arg)); this->Modified(); } }
# 224 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkSetObjectMacro(name,type) virtual void Set ##name (type* _arg) { itkDebugMacro("setting " << #name " to " << _arg ); if (this->m_ ##name != _arg) { this->m_ ##name = _arg; this->Modified(); } }
# 237 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetObjectMacro(name,type) virtual type * Get ##name () { itkDebugMacro("returning " #name " address " << this->m_ ##name ); return this->m_ ##name.GetPointer(); }
# 248 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkSetConstObjectMacro(name,type) virtual void Set ##name (const type* _arg) { itkDebugMacro("setting " << #name " to " << _arg ); if (this->m_ ##name != _arg) { this->m_ ##name = _arg; this->Modified(); } }
# 262 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetConstObjectMacro(name,type) virtual const type * Get ##name () const { itkDebugMacro("returning " #name " address " << this->m_ ##name ); return this->m_ ##name.GetPointer(); }
# 271 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetConstReferenceObjectMacro(name,type) virtual const typename type::Pointer & Get ##name () const { itkDebugMacro("returning " #name " address " << this->m_ ##name ); return this->m_ ##name; }
# 280 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkBooleanMacro(name) virtual void name ##On () { this->Set ##name(true);} virtual void name ##Off () { this->Set ##name(false);}






#define itkSetVectorMacro(name,type,count) virtual void Set ##name(type data[]) { unsigned int i; for (i=0; i<count; i++) { if ( data[i] != this->m_ ##name[i] ) { break; }} if ( i < count ) { this->Modified(); for (i=0; i<count; i++) { this->m_ ##name[i] = data[i]; } } }
# 301 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGetVectorMacro(name,type,count) virtual type *Get ##name () const { return this->m_ ##name; }
# 323 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkNewMacro(x) static Pointer New(void) { Pointer smartPtr; x *rawPtr = ::itk::ObjectFactory<x>::Create(); if(rawPtr == NULL) { rawPtr = new x; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = x::New().GetPointer(); return smartPtr; }
# 360 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkFactorylessNewMacro(x) static Pointer New(void) { Pointer smartPtr; x *rawPtr = new x; smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual LightObject::Pointer CreateAnother(void) const { LightObject::Pointer smartPtr; smartPtr = x::New().GetPointer(); return smartPtr; }
# 378 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkTypeMacro(thisClass,superclass) virtual const char *GetNameOfClass() const {return #thisClass;}




namespace itk
{






extern void OutputWindowDisplayText(const char*);
extern void OutputWindowDisplayErrorText(const char*);
extern void OutputWindowDisplayWarningText(const char*);
extern void OutputWindowDisplayGenericOutputText(const char*);
extern void OutputWindowDisplayDebugText(const char*);
}







#define itkDebugMacro(x) { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " __FILE__ ", line " << __LINE__ << "\n" << this->GetNameOfClass() << " (" << this << "): " x << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }
# 421 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkWarningMacro(x) { if (itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" << this->GetNameOfClass() << " (" << this << "): " x << "\n\n"; itk::OutputWindowDisplayWarningText(itkmsg.str().c_str());} }
# 431 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
namespace itk
{







class OStringStream: public std::ostringstream
{
public:
  OStringStream() {}
private:
  OStringStream(const OStringStream&);
  void operator=(const OStringStream&);
};
# 481 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
}

# 1 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 1
# 24 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h"
#define __itkExceptionObject_h 


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/stdexcept" 1 3
# 40 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/stdexcept" 3
#define _CPP_STDEXCEPT 1

       
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/stdexcept" 3




namespace std
{





  class logic_error : public exception
  {
    string _M_msg;

  public:

    explicit
    logic_error(const string& __arg);

    virtual
    ~logic_error() throw();



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



  class domain_error : public logic_error
  {
  public:
    explicit domain_error(const string& __arg);
  };


  class invalid_argument : public logic_error
  {
  public:
    explicit invalid_argument(const string& __arg);
  };



  class length_error : public logic_error
  {
  public:
    explicit length_error(const string& __arg);
  };



  class out_of_range : public logic_error
  {
  public:
    explicit out_of_range(const string& __arg);
  };






  class runtime_error : public exception
  {
    string _M_msg;

  public:

    explicit
    runtime_error(const string& __arg);

    virtual
    ~runtime_error() throw();



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


  class range_error : public runtime_error
  {
  public:
    explicit range_error(const string& __arg);
  };


  class overflow_error : public runtime_error
  {
  public:
    explicit overflow_error(const string& __arg);
  };


  class underflow_error : public runtime_error
  {
  public:
    explicit underflow_error(const string& __arg);
  };
}
# 28 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 2




namespace itk
{
# 53 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h"
class ExceptionObject : public std::exception
{
public:
  typedef std::exception Superclass;


  ExceptionObject(const char *file="Unknown", unsigned int lineNumber=0,
                  const char *desc="None", const char *loc="Unknown")
  {
    m_Location = loc;
    m_Description = desc;
    m_File = file;
    m_Line = lineNumber;
    this->UpdateWhat();
  };
  ExceptionObject(const std::string& file, unsigned int lineNumber,
                  const std::string& desc="None",
                  const std::string& loc="Unknown")
  {
    m_Location = loc;
    m_Description = desc;
    m_File = file;
    m_Line = lineNumber;
    this->UpdateWhat();
  };
  ExceptionObject( const ExceptionObject &orig ): Superclass()
  {
    m_Location = orig.m_Location;
    m_Description = orig.m_Description;
    m_File = orig.m_File;
    m_Line = orig.m_Line;
    this->UpdateWhat();
  }


  virtual ~ExceptionObject() throw() {}


  ExceptionObject &operator= ( const ExceptionObject &orig )
  {
    m_Location = orig.m_Location;
    m_Description = orig.m_Description;
    m_File = orig.m_File;
    m_Line = orig.m_Line;
    this->UpdateWhat();
    return *this;
  }


  virtual bool operator==( const ExceptionObject &orig )
  {
    if ( m_Location == orig.m_Location &&
         m_Description == orig.m_Description &&
         m_File == orig.m_File &&
         m_Line == orig.m_Line)
      {
      return true;
      }
    else
      {
      return false;
      }
  }

  virtual const char *GetNameOfClass() const
    {return "ExceptionObject";}





  virtual void Print(std::ostream& os) const;




  virtual void SetLocation(const std::string& s)
    { m_Location = s; this->UpdateWhat(); }
  virtual void SetDescription(const std::string& s)
    { m_Description = s; this->UpdateWhat(); }
  virtual void SetLocation(const char * s)
    { m_Location = s; this->UpdateWhat(); }
  virtual void SetDescription (const char *s)
    { m_Description = s; this->UpdateWhat(); }
  virtual const char *GetLocation() const
    { return m_Location.c_str(); }
  virtual const char *GetDescription() const
    { return m_Description.c_str(); }


  virtual const char *GetFile() const
    { return m_File.c_str(); }


  virtual unsigned int GetLine() const
    { return m_Line; }


  virtual const char* what() const throw()
    { return m_What.c_str(); }

protected:
  void UpdateWhat()
    {
    OStringStream loc;
    loc << ":" << m_Line << ":\n";
    m_What = m_File;
    m_What += loc.str();
    m_What += m_Description;
    }
private:

  std::string m_Location;
  std::string m_Description;
  std::string m_What;
  std::string m_File;
  unsigned int m_Line;

};


inline std::ostream& operator<<(std::ostream& os, ExceptionObject &e)
{
  (&e)->Print(os);
  return os;
}
# 188 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h"
class MemoryAllocationError : public ExceptionObject
{
public:


  MemoryAllocationError() : ExceptionObject() {}


  MemoryAllocationError(const char *file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}


  MemoryAllocationError(const std::string& file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}


  MemoryAllocationError(const std::string& file, unsigned int lineNumber, const std::string& desc, const std::string& loc) : ExceptionObject(file, lineNumber, desc, loc) {}


  virtual ~MemoryAllocationError() throw() {}

  virtual const char* GetNameOfClass() const
    { return "MemoryAllocationError"; }
};





class RangeError : public ExceptionObject
{
public:


  RangeError() : ExceptionObject() {}


  RangeError(const char *file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}


  RangeError(const std::string& file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}


  virtual ~RangeError() throw() {}

  virtual const char *GetNameOfClass() const
    {return "RangeError";}

};






class InvalidArgumentError : public ExceptionObject
{
public:




  InvalidArgumentError() : ExceptionObject() {}




  InvalidArgumentError(const char *file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}




  InvalidArgumentError(const std::string& file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}


  virtual ~InvalidArgumentError() throw() {}

  virtual const char *GetNameOfClass() const
    {return "InvalidArgumentError";}
};





class IncompatibleOperandsError : public ExceptionObject
{
public:


  IncompatibleOperandsError() : ExceptionObject() {}


  IncompatibleOperandsError(const char *file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}


  IncompatibleOperandsError(const std::string& file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {}


  virtual ~IncompatibleOperandsError() throw() {}

  virtual const char *GetNameOfClass() const
    {return "IncompatibleOperandsError";}
};





class ProcessAborted : public ExceptionObject
{
public:


  ProcessAborted() : ExceptionObject() {
    this->SetDescription("Filter execution was aborted by an external request"); }


  ProcessAborted(const char *file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {
    this->SetDescription("Filter execution was aborted by an external request"); }


  ProcessAborted(const std::string& file, unsigned int lineNumber) : ExceptionObject(file, lineNumber) {
    this->SetDescription("Filter execution was aborted by an external request"); }


  virtual ~ProcessAborted() throw() {}

  virtual const char *GetNameOfClass() const
    {return "ProcessAborted";}

};


}
# 484 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h" 2




#define itkExceptionMacro(x) { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " x; ::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str()); throw e_; }
# 497 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGenericExceptionMacro(x) { ::itk::OStringStream message; message << "itk::ERROR: " x; ::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str()); throw e_; }
# 508 "/tmp/installed/include/InsightToolkit/Common/itkMacro.h"
#define itkGenericOutputMacro(x) { if (::itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" x << "\n\n"; itk::OutputWindowDisplayGenericOutputText(itkmsg.str().c_str());} }
# 21 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointer.h" 2


namespace itk
{
# 42 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointer.h"
template <class TObjectType>
class SmartPointer
{
public:
  typedef TObjectType ObjectType;


  SmartPointer ()
    { m_Pointer = 0; }


  SmartPointer (const SmartPointer<ObjectType> &p):
    m_Pointer(p.m_Pointer)
    { this->Register(); }


  SmartPointer (ObjectType *p):
    m_Pointer(p)
    { this->Register(); }


  ~SmartPointer ()
    {
    this->UnRegister();
    m_Pointer = 0;
    }


  ObjectType *operator -> () const
    { return m_Pointer; }


  operator ObjectType * () const
    { return m_Pointer; }


  bool IsNotNull() const
  { return m_Pointer != 0; }
  bool IsNull() const
  { return m_Pointer == 0; }


  template <typename R>
  bool operator == ( R r ) const
    { return (m_Pointer == (ObjectType*)(r) ); }

  template <typename R>
  bool operator != ( R r ) const
    { return (m_Pointer != (ObjectType*)(r) ); }


  ObjectType *GetPointer () const
    { return m_Pointer; }


  bool operator < (const SmartPointer &r) const
    { return (void*)m_Pointer < (void*) r.m_Pointer; }


  bool operator > (const SmartPointer &r) const
    { return (void*)m_Pointer > (void*) r.m_Pointer; }


  bool operator <= (const SmartPointer &r) const
    { return (void*)m_Pointer <= (void*) r.m_Pointer; }


  bool operator >= (const SmartPointer &r) const
    { return (void*)m_Pointer >= (void*) r.m_Pointer; }


  SmartPointer &operator = (const SmartPointer &r)
    { return this->operator = (r.GetPointer()); }


  SmartPointer &operator = (ObjectType *r)
    {
    if (m_Pointer != r)
      {
      ObjectType* tmp = m_Pointer;
      m_Pointer = r;
      this->Register();
      if ( tmp ) { tmp->UnRegister(); }
      }
    return *this;
    }


  ObjectType *Print (std::ostream& os) const
    {

      (*m_Pointer).Print(os);
      return m_Pointer;
    }

private:

  ObjectType* m_Pointer;

  void Register()
    {
    if(m_Pointer) { m_Pointer->Register(); }
    }

  void UnRegister()
    {
    if(m_Pointer) { m_Pointer->UnRegister(); }
    }
};


template <typename T>
std::ostream& operator<< (std::ostream& os, SmartPointer<T> p)
{
  p.Print(os);
  return os;
}

}
# 28 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkTimeStamp.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkTimeStamp.h"
#define __itkTimeStamp_h 



namespace itk
{
# 39 "/tmp/installed/include/InsightToolkit/Common/itkTimeStamp.h"
class TimeStamp
{
public:

  typedef TimeStamp Self;



  static Self* New();



  TimeStamp()
    {m_ModifiedTime = 0;}


  void Delete()
    {delete this;}


  static const char *GetNameOfClass()
    {return "TimeStamp";}
# 69 "/tmp/installed/include/InsightToolkit/Common/itkTimeStamp.h"
  void Modified();


  unsigned long int GetMTime() const
    {return m_ModifiedTime;};


  int operator>(TimeStamp& ts)
    {return (m_ModifiedTime > ts.m_ModifiedTime);}
  int operator<(TimeStamp& ts)
    {return (m_ModifiedTime < ts.m_ModifiedTime);}


  operator unsigned long() const
    {return m_ModifiedTime;}

private:
  unsigned long m_ModifiedTime;
};


}
# 29 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkIndent.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkIndent.h"
#define __itkIndent_h 




namespace itk
{
# 41 "/tmp/installed/include/InsightToolkit/Common/itkIndent.h"
class Indent
{
public:

  typedef Indent Self;


  static Self* New();


  void Delete() {delete this;}


  Indent(int ind=0) {m_Indent=ind;}


  static const char *GetNameOfClass() {return "Indent";}



  Indent GetNextIndent();


  friend std::ostream& operator<<(std::ostream& os, const Indent& o);

private:
  int m_Indent;
};

}
# 30 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkSimpleFastMutexLock.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkSimpleFastMutexLock.h"
#define __itkSimpleFastMutexLock_h 
# 37 "/tmp/installed/include/InsightToolkit/Common/itkSimpleFastMutexLock.h"
namespace itk
{
# 47 "/tmp/installed/include/InsightToolkit/Common/itkSimpleFastMutexLock.h"
typedef pthread_mutex_t FastMutexType;
# 74 "/tmp/installed/include/InsightToolkit/Common/itkSimpleFastMutexLock.h"
class SimpleFastMutexLock
{
public:

  typedef SimpleFastMutexLock Self;


  SimpleFastMutexLock();
  ~SimpleFastMutexLock();


  void Lock( void ) const;


  void Unlock( void ) const;

protected:
  mutable FastMutexType m_FastMutexLock;
};

}
# 31 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h" 2



namespace itk
{
# 51 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h"
class LightObject
{
public:

  typedef LightObject Self;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  static Pointer New();






  virtual Pointer CreateAnother() const;




  virtual void Delete();




  virtual const char *GetNameOfClass() const
    {return "LightObject";}
# 89 "/tmp/installed/include/InsightToolkit/Common/itkLightObject.h"
  void Print(std::ostream& os, Indent indent=0) const;



  static void BreakOnError();


  virtual void Register() const;


  virtual void UnRegister() const;


  virtual int GetReferenceCount() const
    {return m_ReferenceCount;}



  virtual void SetReferenceCount(int);

protected:
  LightObject():m_ReferenceCount(1) {}
  virtual ~LightObject();





  virtual void PrintSelf(std::ostream& os, Indent indent) const;
  virtual void PrintHeader(std::ostream& os, Indent indent) const;
  virtual void PrintTrailer(std::ostream& os, Indent indent) const;


  mutable int m_ReferenceCount;


  mutable SimpleFastMutexLock m_ReferenceCountLock;

private:
  LightObject(const Self&);
  void operator=(const Self&);


};

}
# 24 "/tmp/installed/include/InsightToolkit/Common/itkObject.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkEventObject.h" 1
# 19 "/tmp/installed/include/InsightToolkit/Common/itkEventObject.h"
#define __itkEventObject_h 




namespace itk
{
# 58 "/tmp/installed/include/InsightToolkit/Common/itkEventObject.h"
class EventObject
{
public:


  EventObject() {}


  virtual ~EventObject() {}



  virtual EventObject* MakeObject() const=0;




  virtual void Print(std::ostream& os) const;


  virtual const char * GetEventName(void) const=0;


  virtual bool CheckEvent(const EventObject*) const=0;

protected:




  virtual void PrintSelf(std::ostream& os, Indent indent) const;
  virtual void PrintHeader(std::ostream& os, Indent indent) const;
  virtual void PrintTrailer(std::ostream& os, Indent indent) const;

private:
  typedef EventObject * EventFactoryFunction();
  EventObject(const EventObject&);
  void operator=(const EventObject&);
};



inline std::ostream& operator<<(std::ostream& os, EventObject &e)
{
  (&e)->Print(os);
  return os;
}







#define itkEventMacro(classname,super) class classname : public super { public: typedef classname Self; typedef super Superclass; classname() {} virtual ~classname() {} virtual const char * GetEventName() const { return #classname; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: classname(const Self&); void operator=(const Self&); }
# 134 "/tmp/installed/include/InsightToolkit/Common/itkEventObject.h"
class NoEvent : public EventObject { public: typedef NoEvent Self; typedef EventObject Superclass; NoEvent() {} virtual ~NoEvent() {} virtual const char * GetEventName() const { return "NoEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: NoEvent(const Self&); void operator=(const Self&); };
class AnyEvent : public EventObject { public: typedef AnyEvent Self; typedef EventObject Superclass; AnyEvent() {} virtual ~AnyEvent() {} virtual const char * GetEventName() const { return "AnyEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: AnyEvent(const Self&); void operator=(const Self&); };
class DeleteEvent : public AnyEvent { public: typedef DeleteEvent Self; typedef AnyEvent Superclass; DeleteEvent() {} virtual ~DeleteEvent() {} virtual const char * GetEventName() const { return "DeleteEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: DeleteEvent(const Self&); void operator=(const Self&); };
class StartEvent : public AnyEvent { public: typedef StartEvent Self; typedef AnyEvent Superclass; StartEvent() {} virtual ~StartEvent() {} virtual const char * GetEventName() const { return "StartEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: StartEvent(const Self&); void operator=(const Self&); };
class EndEvent : public AnyEvent { public: typedef EndEvent Self; typedef AnyEvent Superclass; EndEvent() {} virtual ~EndEvent() {} virtual const char * GetEventName() const { return "EndEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: EndEvent(const Self&); void operator=(const Self&); };
class ProgressEvent : public AnyEvent { public: typedef ProgressEvent Self; typedef AnyEvent Superclass; ProgressEvent() {} virtual ~ProgressEvent() {} virtual const char * GetEventName() const { return "ProgressEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: ProgressEvent(const Self&); void operator=(const Self&); };
class ExitEvent : public AnyEvent { public: typedef ExitEvent Self; typedef AnyEvent Superclass; ExitEvent() {} virtual ~ExitEvent() {} virtual const char * GetEventName() const { return "ExitEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: ExitEvent(const Self&); void operator=(const Self&); };
class AbortEvent : public AnyEvent { public: typedef AbortEvent Self; typedef AnyEvent Superclass; AbortEvent() {} virtual ~AbortEvent() {} virtual const char * GetEventName() const { return "AbortEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: AbortEvent(const Self&); void operator=(const Self&); };
class ModifiedEvent : public AnyEvent { public: typedef ModifiedEvent Self; typedef AnyEvent Superclass; ModifiedEvent() {} virtual ~ModifiedEvent() {} virtual const char * GetEventName() const { return "ModifiedEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: ModifiedEvent(const Self&); void operator=(const Self&); };
class InitializeEvent : public AnyEvent { public: typedef InitializeEvent Self; typedef AnyEvent Superclass; InitializeEvent() {} virtual ~InitializeEvent() {} virtual const char * GetEventName() const { return "InitializeEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: InitializeEvent(const Self&); void operator=(const Self&); };
class IterationEvent : public AnyEvent { public: typedef IterationEvent Self; typedef AnyEvent Superclass; IterationEvent() {} virtual ~IterationEvent() {} virtual const char * GetEventName() const { return "IterationEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: IterationEvent(const Self&); void operator=(const Self&); };
class PickEvent : public AnyEvent { public: typedef PickEvent Self; typedef AnyEvent Superclass; PickEvent() {} virtual ~PickEvent() {} virtual const char * GetEventName() const { return "PickEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: PickEvent(const Self&); void operator=(const Self&); };
class StartPickEvent : public PickEvent { public: typedef StartPickEvent Self; typedef PickEvent Superclass; StartPickEvent() {} virtual ~StartPickEvent() {} virtual const char * GetEventName() const { return "StartPickEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: StartPickEvent(const Self&); void operator=(const Self&); };
class EndPickEvent : public PickEvent { public: typedef EndPickEvent Self; typedef PickEvent Superclass; EndPickEvent() {} virtual ~EndPickEvent() {} virtual const char * GetEventName() const { return "EndPickEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: EndPickEvent(const Self&); void operator=(const Self&); };
class AbortCheckEvent : public PickEvent { public: typedef AbortCheckEvent Self; typedef PickEvent Superclass; AbortCheckEvent() {} virtual ~AbortCheckEvent() {} virtual const char * GetEventName() const { return "AbortCheckEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: AbortCheckEvent(const Self&); void operator=(const Self&); };

class UserEvent : public AnyEvent { public: typedef UserEvent Self; typedef AnyEvent Superclass; UserEvent() {} virtual ~UserEvent() {} virtual const char * GetEventName() const { return "UserEvent"; } virtual bool CheckEvent(const ::itk::EventObject* e) const { return dynamic_cast<const Self*>(e); } virtual ::itk::EventObject* MakeObject() const { return new Self; } private: UserEvent(const Self&); void operator=(const Self&); };


}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkObject.h" 2

# 1 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataDictionary.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataDictionary.h"
#define MetaDataDictionary_h_h 





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/vector" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/vector" 3
#define _CPP_VECTOR 1

       
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/vector" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 3
#define __throw_exception_again throw
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 67 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/vector" 2 3




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
#define __GLIBCPP_INTERNAL_VECTOR_H 


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 3
#define __throw_exception_again throw
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 66 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 2 3


namespace std
{






  template<typename _Tp, typename _Allocator, bool _IsStatic>
    class _Vector_alloc_base
    {
    public:
      typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
      allocator_type;

      allocator_type
      get_allocator() const { return _M_data_allocator; }

      _Vector_alloc_base(const allocator_type& __a)
      : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
      { }

    protected:
      allocator_type _M_data_allocator;
      _Tp* _M_start;
      _Tp* _M_finish;
      _Tp* _M_end_of_storage;

      _Tp*
      _M_allocate(size_t __n) { return _M_data_allocator.allocate(__n); }

      void
      _M_deallocate(_Tp* __p, size_t __n)
      { if (__p) _M_data_allocator.deallocate(__p, __n); }
    };


  template<typename _Tp, typename _Allocator>
    class _Vector_alloc_base<_Tp, _Allocator, true>
    {
    public:
      typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
             allocator_type;

      allocator_type
      get_allocator() const { return allocator_type(); }

      _Vector_alloc_base(const allocator_type&)
      : _M_start(0), _M_finish(0), _M_end_of_storage(0)
      { }

    protected:
      _Tp* _M_start;
      _Tp* _M_finish;
      _Tp* _M_end_of_storage;

      typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type;

      _Tp*
      _M_allocate(size_t __n) { return _Alloc_type::allocate(__n); }

      void
      _M_deallocate(_Tp* __p, size_t __n) { _Alloc_type::deallocate(__p, __n);}
    };







  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    : public _Vector_alloc_base<_Tp, _Alloc,
                                _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
    {
    public:
      typedef _Vector_alloc_base<_Tp, _Alloc,
                                 _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
         _Base;
      typedef typename _Base::allocator_type allocator_type;

      _Vector_base(const allocator_type& __a)
      : _Base(__a) { }

      _Vector_base(size_t __n, const allocator_type& __a)
      : _Base(__a)
      {
        _M_start = _M_allocate(__n);
        _M_finish = _M_start;
        _M_end_of_storage = _M_start + __n;
      }

      ~_Vector_base()
      { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
    };
# 184 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc = allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {

     

      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef vector<_Tp, _Alloc> vector_type;

    public:
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type>
      const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef typename _Base::allocator_type allocator_type;

    protected:






      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_M_start;
      using _Base::_M_finish;
      using _Base::_M_end_of_storage;

    public:





      explicit
      vector(const allocator_type& __a = allocator_type())
      : _Base(__a) { }
# 238 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      vector(size_type __n, const value_type& __value,
             const allocator_type& __a = allocator_type())
      : _Base(__n, __a)
      { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }
# 250 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      explicit
      vector(size_type __n)
      : _Base(__n, allocator_type())
      { _M_finish = uninitialized_fill_n(_M_start, __n, value_type()); }
# 264 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      vector(const vector& __x)
      : _Base(__x.size(), __x.get_allocator())
      { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }
# 282 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      template<typename _InputIterator>
        vector(_InputIterator __first, _InputIterator __last,
               const allocator_type& __a = allocator_type())
        : _Base(__a)
        {

          typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
          _M_initialize_dispatch(__first, __last, _Integral());
        }






      ~vector() { _Destroy(_M_start, _M_finish); }
# 307 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      vector&
      operator=(const vector& __x);
# 320 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 336 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      template<typename _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {

          typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
          _M_assign_dispatch(__first, __last, _Integral());
        }


      allocator_type
      get_allocator() const { return _Base::get_allocator(); }






      iterator
      begin() { return iterator (_M_start); }






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






      iterator
      end() { return iterator (_M_finish); }





      const_iterator
      end() const { return const_iterator (_M_finish); }






      reverse_iterator
      rbegin() { return reverse_iterator(end()); }






      const_reverse_iterator
      rbegin() const { return const_reverse_iterator(end()); }






      reverse_iterator
      rend() { return reverse_iterator(begin()); }






      const_reverse_iterator
      rend() const { return const_reverse_iterator(begin()); }



      size_type
      size() const { return size_type(end() - begin()); }


      size_type
      max_size() const { return size_type(-1) / sizeof(value_type); }
# 432 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      resize(size_type __new_size, const value_type& __x)
      {
        if (__new_size < size())
          erase(begin() + __new_size, end());
        else
          insert(end(), __new_size - size(), __x);
      }
# 451 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      resize(size_type __new_size) { resize(__new_size, value_type()); }





      size_type
      capacity() const
      { return size_type(const_iterator(_M_end_of_storage) - begin()); }





      bool
      empty() const { return begin() == end(); }
# 486 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      reserve(size_type __n);
# 500 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      reference
      operator[](size_type __n) { return *(begin() + __n); }
# 514 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      const_reference
      operator[](size_type __n) const { return *(begin() + __n); }

    protected:

      void
      _M_range_check(size_type __n) const
      {
        if (__n >= this->size())
          __throw_out_of_range("vector [] access out of range");
      }

    public:
# 538 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      reference
      at(size_type __n) { _M_range_check(__n); return (*this)[__n]; }
# 552 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
# 594 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      push_back(const value_type& __x)
      {
        if (_M_finish != _M_end_of_storage)
          {
            _Construct(_M_finish, __x);
            ++_M_finish;
          }
        else
          _M_insert_aux(end(), __x);
      }
# 614 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      pop_back()
      {
        --_M_finish;
        _Destroy(_M_finish);
      }
# 632 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 669 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      insert(iterator __pos, size_type __n, const value_type& __x)
      { _M_fill_insert(__pos, __n, __x); }
# 687 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      template<typename _InputIterator>
        void
        insert(iterator __pos, _InputIterator __first, _InputIterator __last)
        {

          typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
          _M_insert_dispatch(__pos, __first, __last, _Integral());
        }
# 711 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      iterator
      erase(iterator __position);
# 732 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 744 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
      void
      swap(vector& __x)
      {
        std::swap(_M_start, __x._M_start);
        std::swap(_M_finish, __x._M_finish);
        std::swap(_M_end_of_storage, __x._M_end_of_storage);
      }







      void
      clear() { erase(begin(), end()); }

    protected:






      template<typename _ForwardIterator>
        pointer
        _M_allocate_and_copy(size_type __n,
                             _ForwardIterator __first, _ForwardIterator __last)
        {
          pointer __result = _M_allocate(__n);
          try
            {
              uninitialized_copy(__first, __last, __result);
              return __result;
            }
          catch(...)
            {
              _M_deallocate(__result, __n);
              throw;
            }
        }





      template<typename _Integer>
        void
        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
        {
          _M_start = _M_allocate(__n);
          _M_end_of_storage = _M_start + __n;
          _M_finish = uninitialized_fill_n(_M_start, __n, __value);
        }


      template<typename _InputIter>
        void
        _M_initialize_dispatch(_InputIter __first, _InputIter __last,
                               __false_type)
        {
          typedef typename iterator_traits<_InputIter>::iterator_category
            _IterCategory;
          _M_range_initialize(__first, __last, _IterCategory());
        }


      template<typename _InputIterator>
        void
        _M_range_initialize(_InputIterator __first,
                            _InputIterator __last, input_iterator_tag)
        {
          for ( ; __first != __last; ++__first)
            push_back(*__first);
        }


      template<typename _ForwardIterator>
        void
        _M_range_initialize(_ForwardIterator __first,
                            _ForwardIterator __last, forward_iterator_tag)
        {
          size_type __n = distance(__first, __last);
          _M_start = _M_allocate(__n);
          _M_end_of_storage = _M_start + __n;
          _M_finish = uninitialized_copy(__first, __last, _M_start);
        }






      template<typename _Integer>
        void
        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
        {
          _M_fill_assign(static_cast<size_type>(__n),
                         static_cast<value_type>(__val));
        }


      template<typename _InputIter>
        void
        _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
        {
          typedef typename iterator_traits<_InputIter>::iterator_category
            _IterCategory;
          _M_assign_aux(__first, __last, _IterCategory());
        }


      template<typename _InputIterator>
        void
        _M_assign_aux(_InputIterator __first, _InputIterator __last,
                      input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                      forward_iterator_tag);



      void
      _M_fill_assign(size_type __n, const value_type& __val);





      template<typename _Integer>
        void
        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
                           __true_type)
        {
          _M_fill_insert(__pos, static_cast<size_type>(__n),
                         static_cast<value_type>(__val));
        }


      template<typename _InputIterator>
        void
        _M_insert_dispatch(iterator __pos, _InputIterator __first,
                           _InputIterator __last, __false_type)
        {
          typedef typename 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, input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_range_insert(iterator __pos, _ForwardIterator __first,
                        _ForwardIterator __last, 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);





    };
# 934 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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() &&
             equal(__x.begin(), __x.end(), __y.begin());
    }
# 953 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y)
    {
      return 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); }
}
# 72 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/vector" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_bvector.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_bvector.h" 3
#define __GLIBCPP_INTERNAL_BVECTOR_H 

namespace std
{
  typedef unsigned long _Bit_type;
  enum { _M_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) {}

public:
  _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 iterator<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++ == _M_word_bit - 1) {
      _M_offset = 0;
      ++_M_p;
    }
  }
  void _M_bump_down() {
    if (_M_offset-- == 0) {
      _M_offset = _M_word_bit - 1;
      --_M_p;
    }
  }

  void _M_incr(ptrdiff_t __i) {
    difference_type __n = __i + _M_offset;
    _M_p += __n / _M_word_bit;
    __n = __n % _M_word_bit;
    if (__n < 0) {
      _M_offset = (unsigned int) __n + _M_word_bit;
      --_M_p;
    } else
      _M_offset = (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 _M_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) { 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) {
    return *(*this + __i);
  }
};

inline _Bit_const_iterator
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x) { return __x + __n; }






template <class _Allocator, bool __is_static>
class _Bvector_alloc_base {
public:
  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return _M_data_allocator; }

  _Bvector_alloc_base(const allocator_type& __a)
    : _M_data_allocator(__a), _M_start(), _M_finish(), _M_end_of_storage(0) {}

protected:
  _Bit_type * _M_bit_alloc(size_t __n)
    { return _M_data_allocator.allocate((__n + _M_word_bit - 1)/_M_word_bit); }
  void _M_deallocate() {
    if (_M_start._M_p)
      _M_data_allocator.deallocate(_M_start._M_p,
                                   _M_end_of_storage - _M_start._M_p);
  }

  typename _Alloc_traits<_Bit_type, _Allocator>::allocator_type
          _M_data_allocator;
  _Bit_iterator _M_start;
  _Bit_iterator _M_finish;
  _Bit_type * _M_end_of_storage;
};


template <class _Allocator>
class _Bvector_alloc_base<_Allocator, true> {
public:
  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _Bvector_alloc_base(const allocator_type&)
    : _M_start(), _M_finish(), _M_end_of_storage(0) {}

protected:
  typedef typename _Alloc_traits<_Bit_type, _Allocator>::_Alloc_type
          _Alloc_type;

  _Bit_type * _M_bit_alloc(size_t __n)
    { return _Alloc_type::allocate((__n + _M_word_bit - 1)/_M_word_bit); }
  void _M_deallocate() {
    if (_M_start._M_p)
      _Alloc_type::deallocate(_M_start._M_p,
                              _M_end_of_storage - _M_start._M_p);
  }

  _Bit_iterator _M_start;
  _Bit_iterator _M_finish;
  _Bit_type * _M_end_of_storage;
};

template <class _Alloc>
class _Bvector_base
  : public _Bvector_alloc_base<_Alloc,
                               _Alloc_traits<bool, _Alloc>::_S_instanceless>
{
  typedef _Bvector_alloc_base<_Alloc,
                              _Alloc_traits<bool, _Alloc>::_S_instanceless>
          _Base;
public:
  typedef typename _Base::allocator_type allocator_type;

  _Bvector_base(const allocator_type& __a) : _Base(__a) {}
  ~_Bvector_base() { _Base::_M_deallocate(); }
};

}



namespace std
{

template <typename _Alloc>
  class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
  {
  public:
    typedef bool value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef _Bit_reference reference;
    typedef bool const_reference;
    typedef _Bit_reference* pointer;
    typedef const bool* const_pointer;

    typedef _Bit_iterator iterator;
    typedef _Bit_const_iterator const_iterator;

    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;

    typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type;
    allocator_type get_allocator() const {
      return _Bvector_base<_Alloc>::get_allocator();
    }

  protected:
    using _Bvector_base<_Alloc>::_M_bit_alloc;
    using _Bvector_base<_Alloc>::_M_deallocate;
    using _Bvector_base<_Alloc>::_M_start;
    using _Bvector_base<_Alloc>::_M_finish;
    using _Bvector_base<_Alloc>::_M_end_of_storage;

  protected:
    void _M_initialize(size_type __n) {
      _Bit_type * __q = _M_bit_alloc(__n);
      _M_end_of_storage = __q + (__n + _M_word_bit - 1)/_M_word_bit;
      _M_start = iterator(__q, 0);
      _M_finish = _M_start + difference_type(__n);
    }
    void _M_insert_aux(iterator __position, bool __x) {
      if (_M_finish._M_p != _M_end_of_storage) {
        copy_backward(__position, _M_finish, _M_finish + 1);
        *__position = __x;
        ++_M_finish;
      }
      else {
        size_type __len = size()
                          ? 2 * size() : static_cast<size_type>(_M_word_bit);
        _Bit_type * __q = _M_bit_alloc(__len);
        iterator __i = copy(begin(), __position, iterator(__q, 0));
        *__i++ = __x;
        _M_finish = copy(__position, end(), __i);
        _M_deallocate();
        _M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
        _M_start = iterator(__q, 0);
      }
    }

    template <class _InputIterator>
    void _M_initialize_range(_InputIterator __first, _InputIterator __last,
                             input_iterator_tag) {
      _M_start = iterator();
      _M_finish = iterator();
      _M_end_of_storage = 0;
      for ( ; __first != __last; ++__first)
        push_back(*__first);
    }

    template <class _ForwardIterator>
    void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
                             forward_iterator_tag) {
      size_type __n = distance(__first, __last);
      _M_initialize(__n);
      copy(__first, __last, _M_start);
    }

    template <class _InputIterator>
    void _M_insert_range(iterator __pos,
                         _InputIterator __first, _InputIterator __last,
                         input_iterator_tag) {
      for ( ; __first != __last; ++__first) {
        __pos = insert(__pos, *__first);
        ++__pos;
      }
    }

    template <class _ForwardIterator>
    void _M_insert_range(iterator __position,
                         _ForwardIterator __first, _ForwardIterator __last,
                         forward_iterator_tag) {
      if (__first != __last) {
        size_type __n = distance(__first, __last);
        if (capacity() - size() >= __n) {
          copy_backward(__position, end(), _M_finish + difference_type(__n));
          copy(__first, __last, __position);
          _M_finish += difference_type(__n);
        }
        else {
          size_type __len = size() + max(size(), __n);
          _Bit_type * __q = _M_bit_alloc(__len);
          iterator __i = copy(begin(), __position, iterator(__q, 0));
          __i = copy(__first, __last, __i);
          _M_finish = copy(__position, end(), __i);
          _M_deallocate();
          _M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
          _M_start = iterator(__q, 0);
        }
      }
    }

  public:
    iterator begin() { return _M_start; }
    const_iterator begin() const { return _M_start; }
    iterator end() { return _M_finish; }
    const_iterator end() const { return _M_finish; }

    reverse_iterator rbegin() { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const {
      return const_reverse_iterator(end());
    }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const {
      return const_reverse_iterator(begin());
    }

    size_type size() const { return size_type(end() - begin()); }
    size_type max_size() const { return size_type(-1); }
    size_type capacity() const {
      return size_type(const_iterator(_M_end_of_storage, 0) - begin());
    }
    bool empty() const { return begin() == end(); }

    reference operator[](size_type __n)
      { return *(begin() + difference_type(__n)); }
    const_reference operator[](size_type __n) const
      { return *(begin() + difference_type(__n)); }

    void _M_range_check(size_type __n) const {
      if (__n >= this->size())
        __throw_out_of_range("vector<bool>");
    }

    reference at(size_type __n)
      { _M_range_check(__n); return (*this)[__n]; }
    const_reference at(size_type __n) const
      { _M_range_check(__n); return (*this)[__n]; }

    explicit vector(const allocator_type& __a = allocator_type())
      : _Bvector_base<_Alloc>(__a) {}

    vector(size_type __n, bool __value,
              const allocator_type& __a = allocator_type())
      : _Bvector_base<_Alloc>(__a)
    {
      _M_initialize(__n);
      fill(_M_start._M_p, _M_end_of_storage, __value ? ~0 : 0);
    }

    explicit vector(size_type __n)
      : _Bvector_base<_Alloc>(allocator_type())
    {
      _M_initialize(__n);
      fill(_M_start._M_p, _M_end_of_storage, 0);
    }

    vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator()) {
      _M_initialize(__x.size());
      copy(__x.begin(), __x.end(), _M_start);
    }



    template <class _Integer>
    void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
      _M_initialize(__n);
      fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
    }

    template <class _InputIterator>
    void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
                                __false_type) {
      _M_initialize_range(__first, __last, __iterator_category(__first));
    }

    template <class _InputIterator>
    vector(_InputIterator __first, _InputIterator __last,
             const allocator_type& __a = allocator_type())
      : _Bvector_base<_Alloc>(__a)
    {
      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
      _M_initialize_dispatch(__first, __last, _Integral());
    }

    ~vector() { }

    vector& operator=(const vector& __x) {
      if (&__x == this) return *this;
      if (__x.size() > capacity()) {
        _M_deallocate();
        _M_initialize(__x.size());
      }
      copy(__x.begin(), __x.end(), begin());
      _M_finish = begin() + difference_type(__x.size());
      return *this;
    }






    void _M_fill_assign(size_t __n, bool __x) {
      if (__n > size()) {
        fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
        insert(end(), __n - size(), __x);
      }
      else {
        erase(begin() + __n, end());
        fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
      }
    }

    void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }

    template <class _InputIterator>
    void assign(_InputIterator __first, _InputIterator __last) {
      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
      _M_assign_dispatch(__first, __last, _Integral());
    }

    template <class _Integer>
    void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
      { _M_fill_assign((size_t) __n, (bool) __val); }

    template <class _InputIter>
    void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
      { _M_assign_aux(__first, __last, __iterator_category(__first)); }

    template <class _InputIterator>
    void _M_assign_aux(_InputIterator __first, _InputIterator __last,
                       input_iterator_tag) {
      iterator __cur = begin();
      for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
        *__cur = *__first;
      if (__first == __last)
        erase(__cur, end());
      else
        insert(end(), __first, __last);
    }

    template <class _ForwardIterator>
    void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                       forward_iterator_tag) {
      size_type __len = distance(__first, __last);
      if (__len < size())
        erase(copy(__first, __last, begin()), end());
      else {
        _ForwardIterator __mid = __first;
        advance(__mid, size());
        copy(__first, __mid, begin());
        insert(end(), __mid, __last);
      }
    }

    void reserve(size_type __n) {
      if (__n > this->max_size())
        __throw_length_error("vector::reserve");
      if (this->capacity() < __n) {
        _Bit_type * __q = _M_bit_alloc(__n);
        _M_finish = copy(begin(), end(), iterator(__q, 0));
        _M_deallocate();
        _M_start = iterator(__q, 0);
        _M_end_of_storage = __q + (__n + _M_word_bit - 1)/_M_word_bit;
      }
    }

    reference front() { return *begin(); }
    const_reference front() const { return *begin(); }
    reference back() { return *(end() - 1); }
    const_reference back() const { return *(end() - 1); }
    void push_back(bool __x) {
      if (_M_finish._M_p != _M_end_of_storage)
        *_M_finish++ = __x;
      else
        _M_insert_aux(end(), __x);
    }
    void swap(vector<bool, _Alloc>& __x) {
      std::swap(_M_start, __x._M_start);
      std::swap(_M_finish, __x._M_finish);
      std::swap(_M_end_of_storage, __x._M_end_of_storage);
    }


    static void swap(reference __x, reference __y) {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    iterator insert(iterator __position, bool __x = bool()) {
      difference_type __n = __position - begin();
      if (_M_finish._M_p != _M_end_of_storage && __position == end())
        *_M_finish++ = __x;
      else
        _M_insert_aux(__position, __x);
      return begin() + __n;
    }



    template <class _Integer>
    void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
                            __true_type) {
      _M_fill_insert(__pos, __n, __x);
    }

    template <class _InputIterator>
    void _M_insert_dispatch(iterator __pos,
                            _InputIterator __first, _InputIterator __last,
                            __false_type) {
      _M_insert_range(__pos, __first, __last, __iterator_category(__first));
    }

    template <class _InputIterator>
    void insert(iterator __position,
                _InputIterator __first, _InputIterator __last) {
      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
      _M_insert_dispatch(__position, __first, __last, _Integral());
    }

    void _M_fill_insert(iterator __position, size_type __n, bool __x) {
      if (__n == 0) return;
      if (capacity() - size() >= __n) {
        copy_backward(__position, end(), _M_finish + difference_type(__n));
        fill(__position, __position + difference_type(__n), __x);
        _M_finish += difference_type(__n);
      }
      else {
        size_type __len = size() + max(size(), __n);
        _Bit_type * __q = _M_bit_alloc(__len);
        iterator __i = copy(begin(), __position, iterator(__q, 0));
        fill_n(__i, __n, __x);
        _M_finish = copy(__position, end(), __i + difference_type(__n));
        _M_deallocate();
        _M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
        _M_start = iterator(__q, 0);
      }
    }

    void insert(iterator __position, size_type __n, bool __x) {
      _M_fill_insert(__position, __n, __x);
    }

    void pop_back() { --_M_finish; }
    iterator erase(iterator __position) {
      if (__position + 1 != end())
        copy(__position + 1, end(), __position);
        --_M_finish;
      return __position;
    }
    iterator erase(iterator __first, iterator __last) {
      _M_finish = copy(__last, end(), __first);
      return __first;
    }
    void resize(size_type __new_size, bool __x = bool()) {
      if (__new_size < size())
        erase(begin() + difference_type(__new_size), end());
      else
        insert(end(), __new_size - size(), __x);
    }
    void flip() {
      for (_Bit_type * __p = _M_start._M_p; __p != _M_end_of_storage; ++__p)
        *__p = ~*__p;
    }

    void clear() { erase(begin(), end()); }
  };


typedef vector<bool, __alloc> bit_vector;

}
# 73 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/vector" 2 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/vector.tcc" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/vector.tcc" 3
#define __GLIBCPP_INTERNAL_VECTOR_TCC 

namespace std
{
  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp,_Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
        __throw_length_error("vector::reserve");
      if (this->capacity() < __n)
        {
          const size_type __old_size = size();
          pointer __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);
          _Destroy(_M_start, _M_finish);
          _M_deallocate(_M_start, _M_end_of_storage - _M_start);
          _M_start = __tmp;
          _M_finish = __tmp + __old_size;
          _M_end_of_storage = _M_start + __n;
        }
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp,_Alloc>::iterator
    vector<_Tp,_Alloc>::
    insert(iterator __position, const value_type& __x)
    {
      size_type __n = __position - begin();
      if (_M_finish != _M_end_of_storage && __position == end())
      {
        _Construct(_M_finish, __x);
        ++_M_finish;
      }
      else
        _M_insert_aux(__position, __x);
      return begin() + __n;
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp,_Alloc>::iterator
    vector<_Tp,_Alloc>::
    erase(iterator __position)
    {
      if (__position + 1 != end())
        copy(__position + 1, end(), __position);
      --_M_finish;
      _Destroy(_M_finish);
      return __position;
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp,_Alloc>::iterator
    vector<_Tp,_Alloc>::
    erase(iterator __first, iterator __last)
    {
      iterator __i(copy(__last, end(), __first));
      _Destroy(__i, end());
      _M_finish = _M_finish - (__last - __first);
      return __first;
    }

  template<typename _Tp, typename _Alloc>
    vector<_Tp,_Alloc>&
    vector<_Tp,_Alloc>::
    operator=(const vector<_Tp,_Alloc>& __x)
    {
      if (&__x != this)
      {
        const size_type __xlen = __x.size();
        if (__xlen > capacity())
        {
          pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());
          _Destroy(_M_start, _M_finish);
          _M_deallocate(_M_start, _M_end_of_storage - _M_start);
          _M_start = __tmp;
          _M_end_of_storage = _M_start + __xlen;
        }
        else if (size() >= __xlen)
        {
          iterator __i(copy(__x.begin(), __x.end(), begin()));
          _Destroy(__i, end());
        }
        else
        {
          copy(__x.begin(), __x.begin() + size(), _M_start);
          uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish);
        }
        _M_finish = _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, get_allocator());
        __tmp.swap(*this);
      }
      else if (__n > size())
      {
        fill(begin(), end(), __val);
        _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val);
      }
      else
        erase(fill_n(begin(), __n, __val), end());
    }

  template<typename _Tp, typename _Alloc> template<typename _InputIter>
    void
    vector<_Tp,_Alloc>::
    _M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
    {
      iterator __cur(begin());
      for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
        *__cur = *__first;
      if (__first == __last)
        erase(__cur, end());
      else
        insert(end(), __first, __last);
    }

  template<typename _Tp, typename _Alloc> template<typename _ForwardIter>
    void
    vector<_Tp,_Alloc>::
    _M_assign_aux(_ForwardIter __first, _ForwardIter __last,
                  forward_iterator_tag)
    {
      size_type __len = distance(__first, __last);

      if (__len > capacity())
      {
        pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
        _Destroy(_M_start, _M_finish);
        _M_deallocate(_M_start, _M_end_of_storage - _M_start);
        _M_start = __tmp;
        _M_end_of_storage = _M_finish = _M_start + __len;
      }
      else if (size() >= __len)
      {
        iterator __new_finish(copy(__first, __last, _M_start));
        _Destroy(__new_finish, end());
        _M_finish = __new_finish.base();
      }
      else
      {
        _ForwardIter __mid = __first;
        advance(__mid, size());
        copy(__first, __mid, _M_start);
        _M_finish = uninitialized_copy(__mid, __last, _M_finish);
      }
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp,_Alloc>::
    _M_insert_aux(iterator __position, const _Tp& __x)
    {
      if (_M_finish != _M_end_of_storage)
      {
        _Construct(_M_finish, *(_M_finish - 1));
        ++_M_finish;
        _Tp __x_copy = __x;
        copy_backward(__position, iterator(_M_finish-2), iterator(_M_finish-1));
        *__position = __x_copy;
      }
      else
      {
        const size_type __old_size = size();
        const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
        iterator __new_start(_M_allocate(__len));
        iterator __new_finish(__new_start);
        try
          {
            __new_finish = uninitialized_copy(iterator(_M_start), __position,
                                              __new_start);
            _Construct(__new_finish.base(), __x);
            ++__new_finish;
            __new_finish = uninitialized_copy(__position, iterator(_M_finish),
                                              __new_finish);
          }
        catch(...)
          {
            _Destroy(__new_start,__new_finish);
            _M_deallocate(__new_start.base(),__len);
            throw;
          }
        _Destroy(begin(), end());
        _M_deallocate(_M_start, _M_end_of_storage - _M_start);
        _M_start = __new_start.base();
        _M_finish = __new_finish.base();
        _M_end_of_storage = __new_start.base() + __len;
      }
    }
# 305 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/vector.tcc" 3
  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp,_Alloc>::
    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
    {
      if (__n != 0)
      {
        if (size_type(_M_end_of_storage - _M_finish) >= __n)
          {
           value_type __x_copy = __x;
           const size_type __elems_after = end() - __position;
           iterator __old_finish(_M_finish);
           if (__elems_after > __n)
             {
               uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
               _M_finish += __n;
               copy_backward(__position, __old_finish - __n, __old_finish);
               fill(__position, __position + __n, __x_copy);
             }
           else
             {
               uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
               _M_finish += __n - __elems_after;
               uninitialized_copy(__position, __old_finish, _M_finish);
               _M_finish += __elems_after;
               fill(__position, __old_finish, __x_copy);
             }
          }
        else
          {
            const size_type __old_size = size();
            const size_type __len = __old_size + max(__old_size, __n);
            iterator __new_start(_M_allocate(__len));
            iterator __new_finish(__new_start);
            try
              {
                __new_finish = uninitialized_copy(begin(), __position,
                                                  __new_start);
                __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
                __new_finish = uninitialized_copy(__position, end(),
                                                  __new_finish);
              }
            catch(...)
              {
                _Destroy(__new_start,__new_finish);
                _M_deallocate(__new_start.base(),__len);
                throw;
              }
            _Destroy(_M_start, _M_finish);
            _M_deallocate(_M_start, _M_end_of_storage - _M_start);
            _M_start = __new_start.base();
            _M_finish = __new_finish.base();
            _M_end_of_storage = __new_start.base() + __len;
          }
      }
    }

  template<typename _Tp, typename _Alloc> template<typename _InputIterator>
    void
    vector<_Tp,_Alloc>::
    _M_range_insert(iterator __pos,
                    _InputIterator __first, _InputIterator __last,
                    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, forward_iterator_tag)
    {
      if (__first != __last)
      {
        size_type __n = distance(__first, __last);
        if (size_type(_M_end_of_storage - _M_finish) >= __n)
        {
          const size_type __elems_after = end() - __position;
          iterator __old_finish(_M_finish);
          if (__elems_after > __n)
          {
            uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
            _M_finish += __n;
            copy_backward(__position, __old_finish - __n, __old_finish);
            copy(__first, __last, __position);
          }
          else
          {
            _ForwardIterator __mid = __first;
            advance(__mid, __elems_after);
            uninitialized_copy(__mid, __last, _M_finish);
            _M_finish += __n - __elems_after;
            uninitialized_copy(__position, __old_finish, _M_finish);
            _M_finish += __elems_after;
            copy(__first, __mid, __position);
          }
        }
        else
        {
          const size_type __old_size = size();
          const size_type __len = __old_size + max(__old_size, __n);
          iterator __new_start(_M_allocate(__len));
          iterator __new_finish(__new_start);
          try
            {
              __new_finish = uninitialized_copy(iterator(_M_start),
                                                __position, __new_start);
              __new_finish = uninitialized_copy(__first, __last, __new_finish);
              __new_finish = uninitialized_copy(__position, iterator(_M_finish),
                                                __new_finish);
            }
          catch(...)
            {
              _Destroy(__new_start,__new_finish);
              _M_deallocate(__new_start.base(), __len);
              throw;
            }
          _Destroy(_M_start, _M_finish);
          _M_deallocate(_M_start, _M_end_of_storage - _M_start);
          _M_start = __new_start.base();
          _M_finish = __new_finish.base();
          _M_end_of_storage = __new_start.base() + __len;
        }
      }
    }
}
# 76 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/vector" 2 3
# 28 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataDictionary.h" 2
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/map" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/map" 3
#define _CPP_MAP 1

       
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/map" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_tree.h" 1 3
# 64 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_tree.h" 3
#define __GLIBCPP_INTERNAL_TREE_H 
# 91 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_tree.h" 3
namespace std
{
  enum _Rb_tree_color { _M_red = false, _M_black = true };

  struct _Rb_tree_node_base
  {
    typedef _Rb_tree_node_base* _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 _Base_ptr
    _S_maximum(_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;
    };

  struct _Rb_tree_base_iterator
  {
    typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
    typedef bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t difference_type;

    _Base_ptr _M_node;

    void
    _M_increment()
    {
      if (_M_node->_M_right != 0)
        {
          _M_node = _M_node->_M_right;
          while (_M_node->_M_left != 0)
            _M_node = _M_node->_M_left;
        }
      else
        {
          _Base_ptr __y = _M_node->_M_parent;
          while (_M_node == __y->_M_right)
            {
              _M_node = __y;
              __y = __y->_M_parent;
            }
          if (_M_node->_M_right != __y)
            _M_node = __y;
        }
    }

    void
    _M_decrement()
    {
      if (_M_node->_M_color == _M_red
          && _M_node->_M_parent->_M_parent == _M_node)
        _M_node = _M_node->_M_right;
      else if (_M_node->_M_left != 0)
        {
          _Base_ptr __y = _M_node->_M_left;
          while (__y->_M_right != 0)
            __y = __y->_M_right;
          _M_node = __y;
        }
      else
        {
          _Base_ptr __y = _M_node->_M_parent;
          while (_M_node == __y->_M_left)
            {
              _M_node = __y;
              __y = __y->_M_parent;
            }
          _M_node = __y;
        }
    }
  };

  template<typename _Val, typename _Ref, typename _Ptr>
    struct _Rb_tree_iterator : public _Rb_tree_base_iterator
    {
      typedef _Val value_type;
      typedef _Ref reference;
      typedef _Ptr pointer;
      typedef _Rb_tree_iterator<_Val, _Val&, _Val*> iterator;
      typedef _Rb_tree_iterator<_Val, const _Val&, const _Val*>
      const_iterator;
      typedef _Rb_tree_iterator<_Val, _Ref, _Ptr> _Self;
      typedef _Rb_tree_node<_Val>* _Link_type;

      _Rb_tree_iterator() {}
      _Rb_tree_iterator(_Link_type __x) { _M_node = __x; }
      _Rb_tree_iterator(const iterator& __it) { _M_node = __it._M_node; }

      reference
      operator*() const { return _Link_type(_M_node)->_M_value_field; }

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

      _Self&
      operator++()
      {
        _M_increment();
        return *this;
      }

      _Self
      operator++(int)
      {
        _Self __tmp = *this;
        _M_increment();
        return __tmp;
      }

      _Self&
      operator--() { _M_decrement(); return *this; }

      _Self
      operator--(int)
      {
        _Self __tmp = *this;
        _M_decrement();
        return __tmp;
      }
  };

  template<typename _Val, typename _Ref, typename _Ptr>
    inline bool
    operator==(const _Rb_tree_iterator<_Val, _Ref, _Ptr>& __x,
               const _Rb_tree_iterator<_Val, _Ref, _Ptr>& __y)
    { return __x._M_node == __y._M_node; }

  template<typename _Val>
    inline bool
    operator==(const _Rb_tree_iterator<_Val, const _Val&, const _Val*>& __x,
               const _Rb_tree_iterator<_Val, _Val&, _Val*>& __y)
    { return __x._M_node == __y._M_node; }

  template<typename _Val>
    inline bool
    operator==(const _Rb_tree_iterator<_Val, _Val&, _Val*>& __x,
               const _Rb_tree_iterator<_Val, const _Val&, const _Val*>& __y)
    { return __x._M_node == __y._M_node; }

  template<typename _Val, typename _Ref, typename _Ptr>
    inline bool
    operator!=(const _Rb_tree_iterator<_Val, _Ref, _Ptr>& __x,
               const _Rb_tree_iterator<_Val, _Ref, _Ptr>& __y)
    { return __x._M_node != __y._M_node; }

  template<typename _Val>
    inline bool
    operator!=(const _Rb_tree_iterator<_Val, const _Val&, const _Val*>& __x,
               const _Rb_tree_iterator<_Val, _Val&, _Val*>& __y)
    { return __x._M_node != __y._M_node; }

  template<typename _Val>
    inline bool
    operator!=(const _Rb_tree_iterator<_Val, _Val&, _Val*>& __x,
               const _Rb_tree_iterator<_Val, const _Val&, const _Val*>& __y)
    { return __x._M_node != __y._M_node; }

  inline void
  _Rb_tree_rotate_left(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
  {
    _Rb_tree_node_base* __y = __x->_M_right;
    __x->_M_right = __y->_M_left;
    if (__y->_M_left !=0)
      __y->_M_left->_M_parent = __x;
    __y->_M_parent = __x->_M_parent;

    if (__x == __root)
      __root = __y;
    else if (__x == __x->_M_parent->_M_left)
      __x->_M_parent->_M_left = __y;
    else
      __x->_M_parent->_M_right = __y;
    __y->_M_left = __x;
    __x->_M_parent = __y;
  }

  inline void
  _Rb_tree_rotate_right(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
  {
    _Rb_tree_node_base* __y = __x->_M_left;
    __x->_M_left = __y->_M_right;
    if (__y->_M_right != 0)
      __y->_M_right->_M_parent = __x;
    __y->_M_parent = __x->_M_parent;

    if (__x == __root)
      __root = __y;
    else if (__x == __x->_M_parent->_M_right)
      __x->_M_parent->_M_right = __y;
    else
      __x->_M_parent->_M_left = __y;
    __y->_M_right = __x;
    __x->_M_parent = __y;
  }

  inline void
  _Rb_tree_rebalance(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
  {
    __x->_M_color = _M_red;
    while (__x != __root
           && __x->_M_parent->_M_color == _M_red)
      {
        if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left)
          {
            _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right;
            if (__y && __y->_M_color == _M_red)
              {
                __x->_M_parent->_M_color = _M_black;
                __y->_M_color = _M_black;
                __x->_M_parent->_M_parent->_M_color = _M_red;
                __x = __x->_M_parent->_M_parent;
              }
            else
              {
                if (__x == __x->_M_parent->_M_right)
                  {
                    __x = __x->_M_parent;
                    _Rb_tree_rotate_left(__x, __root);
                  }
                __x->_M_parent->_M_color = _M_black;
                __x->_M_parent->_M_parent->_M_color = _M_red;
                _Rb_tree_rotate_right(__x->_M_parent->_M_parent, __root);
              }
          }
        else
          {
            _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;
            if (__y && __y->_M_color == _M_red)
              {
                __x->_M_parent->_M_color = _M_black;
                __y->_M_color = _M_black;
                __x->_M_parent->_M_parent->_M_color = _M_red;
                __x = __x->_M_parent->_M_parent;
              }
            else
              {
                if (__x == __x->_M_parent->_M_left)
                  {
                    __x = __x->_M_parent;
                    _Rb_tree_rotate_right(__x, __root);
                  }
                __x->_M_parent->_M_color = _M_black;
                __x->_M_parent->_M_parent->_M_color = _M_red;
                _Rb_tree_rotate_left(__x->_M_parent->_M_parent, __root);
              }
          }
      }
    __root->_M_color = _M_black;
  }

  inline _Rb_tree_node_base*
  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* __z,
                               _Rb_tree_node_base*& __root,
                               _Rb_tree_node_base*& __leftmost,
                               _Rb_tree_node_base*& __rightmost)
  {
    _Rb_tree_node_base* __y = __z;
    _Rb_tree_node_base* __x = 0;
    _Rb_tree_node_base* __x_parent = 0;
    if (__y->_M_left == 0)
      __x = __y->_M_right;
    else
      if (__y->_M_right == 0)
        __x = __y->_M_left;
      else
        {

          __y = __y->_M_right;
          while (__y->_M_left != 0)
            __y = __y->_M_left;
          __x = __y->_M_right;
        }
    if (__y != __z)
      {

        __z->_M_left->_M_parent = __y;
        __y->_M_left = __z->_M_left;
        if (__y != __z->_M_right)
          {
            __x_parent = __y->_M_parent;
            if (__x) __x->_M_parent = __y->_M_parent;
            __y->_M_parent->_M_left = __x;
            __y->_M_right = __z->_M_right;
            __z->_M_right->_M_parent = __y;
          }
        else
          __x_parent = __y;
        if (__root == __z)
          __root = __y;
        else if (__z->_M_parent->_M_left == __z)
          __z->_M_parent->_M_left = __y;
        else
          __z->_M_parent->_M_right = __y;
        __y->_M_parent = __z->_M_parent;
        std::swap(__y->_M_color, __z->_M_color);
        __y = __z;

      }
    else
      {
        __x_parent = __y->_M_parent;
        if (__x)
          __x->_M_parent = __y->_M_parent;
        if (__root == __z)
          __root = __x;
        else
          if (__z->_M_parent->_M_left == __z)
            __z->_M_parent->_M_left = __x;
          else
            __z->_M_parent->_M_right = __x;
        if (__leftmost == __z)
          if (__z->_M_right == 0)
            __leftmost = __z->_M_parent;

          else
            __leftmost = _Rb_tree_node_base::_S_minimum(__x);
        if (__rightmost == __z)
          if (__z->_M_left == 0)
            __rightmost = __z->_M_parent;

          else
            __rightmost = _Rb_tree_node_base::_S_maximum(__x);
      }
    if (__y->_M_color != _M_red)
      {
        while (__x != __root && (__x == 0 || __x->_M_color == _M_black))
          if (__x == __x_parent->_M_left)
            {
              _Rb_tree_node_base* __w = __x_parent->_M_right;
              if (__w->_M_color == _M_red)
                {
                  __w->_M_color = _M_black;
                  __x_parent->_M_color = _M_red;
                  _Rb_tree_rotate_left(__x_parent, __root);
                  __w = __x_parent->_M_right;
                }
              if ((__w->_M_left == 0 ||
                   __w->_M_left->_M_color == _M_black) &&
                  (__w->_M_right == 0 ||
                   __w->_M_right->_M_color == _M_black))
                {
                  __w->_M_color = _M_red;
                  __x = __x_parent;
                  __x_parent = __x_parent->_M_parent;
                }
              else
                {
                  if (__w->_M_right == 0
                      || __w->_M_right->_M_color == _M_black)
                    {
                      __w->_M_left->_M_color = _M_black;
                      __w->_M_color = _M_red;
                      _Rb_tree_rotate_right(__w, __root);
                      __w = __x_parent->_M_right;
                    }
                  __w->_M_color = __x_parent->_M_color;
                  __x_parent->_M_color = _M_black;
                  if (__w->_M_right)
                    __w->_M_right->_M_color = _M_black;
                  _Rb_tree_rotate_left(__x_parent, __root);
                  break;
                }
            }
          else
            {

              _Rb_tree_node_base* __w = __x_parent->_M_left;
              if (__w->_M_color == _M_red)
                {
                  __w->_M_color = _M_black;
                  __x_parent->_M_color = _M_red;
                  _Rb_tree_rotate_right(__x_parent, __root);
                  __w = __x_parent->_M_left;
                }
              if ((__w->_M_right == 0 ||
                   __w->_M_right->_M_color == _M_black) &&
                  (__w->_M_left == 0 ||
                   __w->_M_left->_M_color == _M_black))
                {
                  __w->_M_color = _M_red;
                  __x = __x_parent;
                  __x_parent = __x_parent->_M_parent;
                }
              else
                {
                  if (__w->_M_left == 0 || __w->_M_left->_M_color == _M_black)
                    {
                      __w->_M_right->_M_color = _M_black;
                      __w->_M_color = _M_red;
                      _Rb_tree_rotate_left(__w, __root);
                      __w = __x_parent->_M_left;
                    }
                  __w->_M_color = __x_parent->_M_color;
                  __x_parent->_M_color = _M_black;
                  if (__w->_M_left)
                    __w->_M_left->_M_color = _M_black;
                  _Rb_tree_rotate_right(__x_parent, __root);
                  break;
                }
            }
        if (__x) __x->_M_color = _M_black;
      }
    return __y;
  }







  template<typename _Tp, typename _Alloc, bool _S_instanceless>
    class _Rb_tree_alloc_base
    {
    public:
    typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;

      allocator_type
      get_allocator() const { return _M_node_allocator; }

      _Rb_tree_alloc_base(const allocator_type& __a)
      : _M_node_allocator(__a), _M_header(0) {}

    protected:
      typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::allocator_type
      _M_node_allocator;

      _Rb_tree_node<_Tp>* _M_header;

      _Rb_tree_node<_Tp>*
      _M_get_node() { return _M_node_allocator.allocate(1); }

      void
      _M_put_node(_Rb_tree_node<_Tp>* __p)
      { _M_node_allocator.deallocate(__p, 1); }
    };


  template<typename _Tp, typename _Alloc>
    class _Rb_tree_alloc_base<_Tp, _Alloc, true>
    {
    public:
    typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
      allocator_type get_allocator() const { return allocator_type(); }

      _Rb_tree_alloc_base(const allocator_type&) : _M_header(0) {}

    protected:
      _Rb_tree_node<_Tp>* _M_header;

      typedef typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::_Alloc_type
      _Alloc_type;

      _Rb_tree_node<_Tp>*
      _M_get_node() { return _Alloc_type::allocate(1); }

      void
      _M_put_node(_Rb_tree_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }
    };

  template<typename _Tp, typename _Alloc>
    struct _Rb_tree_base : public _Rb_tree_alloc_base<_Tp, _Alloc,
                                  _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
    {
      typedef _Rb_tree_alloc_base<_Tp,
        _Alloc, _Alloc_traits<_Tp, _Alloc>::_S_instanceless> _Base;
      typedef typename _Base::allocator_type allocator_type;

      _Rb_tree_base(const allocator_type& __a)
      : _Base(__a) { _M_header = _M_get_node(); }
      ~_Rb_tree_base() { _M_put_node(_M_header); }
    };


  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc = allocator<_Val> >
    class _Rb_tree : protected _Rb_tree_base<_Val, _Alloc>
    {
      typedef _Rb_tree_base<_Val, _Alloc> _Base;

    protected:
      typedef _Rb_tree_node_base* _Base_ptr;
      typedef _Rb_tree_node<_Val> _Rb_tree_node;

    public:
      typedef _Key key_type;
      typedef _Val value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef _Rb_tree_node* _Link_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;

      typedef typename _Base::allocator_type allocator_type;
      allocator_type get_allocator() const { return _Base::get_allocator(); }

    protected:
      using _Base::_M_get_node;
      using _Base::_M_put_node;
      using _Base::_M_header;

      _Link_type
      _M_create_node(const value_type& __x)
      {
        _Link_type __tmp = _M_get_node();
        try
          { _Construct(&__tmp->_M_value_field, __x); }
        catch(...)
          {
          _M_put_node(__tmp);
          throw;
          }
        return __tmp;
      }

      _Link_type
      _M_clone_node(_Link_type __x)
      {
        _Link_type __tmp = _M_create_node(__x->_M_value_field);
        __tmp->_M_color = __x->_M_color;
        __tmp->_M_left = 0;
        __tmp->_M_right = 0;
        return __tmp;
      }

      void
      destroy_node(_Link_type __p)
      {
        _Destroy(&__p->_M_value_field);
        _M_put_node(__p);
      }

      size_type _M_node_count;
      _Compare _M_key_compare;

      _Link_type&
      _M_root() const { return (_Link_type&) _M_header->_M_parent; }

      _Link_type&
      _M_leftmost() const { return (_Link_type&) _M_header->_M_left; }

      _Link_type&
      _M_rightmost() const { return (_Link_type&) _M_header->_M_right; }

      static _Link_type&
      _S_left(_Link_type __x) { return (_Link_type&)(__x->_M_left); }

      static _Link_type&
      _S_right(_Link_type __x) { return (_Link_type&)(__x->_M_right); }

      static _Link_type&
      _S_parent(_Link_type __x) { return (_Link_type&)(__x->_M_parent); }

      static reference
      _S_value(_Link_type __x) { return __x->_M_value_field; }

      static const _Key&
      _S_key(_Link_type __x) { return _KeyOfValue()(_S_value(__x)); }

      static _Rb_tree_color&
      _S_color(_Link_type __x) { return __x->_M_color; }

      static _Link_type&
      _S_left(_Base_ptr __x) { return (_Link_type&)(__x->_M_left); }

      static _Link_type&
      _S_right(_Base_ptr __x) { return (_Link_type&)(__x->_M_right); }

      static _Link_type&
      _S_parent(_Base_ptr __x) { return (_Link_type&)(__x->_M_parent); }

      static reference
      _S_value(_Base_ptr __x) { return ((_Link_type)__x)->_M_value_field; }

      static const _Key&
      _S_key(_Base_ptr __x) { return _KeyOfValue()(_S_value(_Link_type(__x)));}

      static _Rb_tree_color&
      _S_color(_Base_ptr __x) { return (_Link_type(__x)->_M_color); }

      static _Link_type
      _S_minimum(_Link_type __x)
      { return (_Link_type) _Rb_tree_node_base::_S_minimum(__x); }

      static _Link_type
      _S_maximum(_Link_type __x)
      { return (_Link_type) _Rb_tree_node_base::_S_maximum(__x); }

    public:
      typedef _Rb_tree_iterator<value_type, reference, pointer> iterator;
      typedef _Rb_tree_iterator<value_type, const_reference, const_pointer>
      const_iterator;

      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;

    private:
      iterator
      _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);

      _Link_type
      _M_copy(_Link_type __x, _Link_type __p);

      void
      _M_erase(_Link_type __x);

    public:

      _Rb_tree()
        : _Base(allocator_type()), _M_node_count(0), _M_key_compare()
      { _M_empty_initialize(); }

      _Rb_tree(const _Compare& __comp)
        : _Base(allocator_type()), _M_node_count(0), _M_key_compare(__comp)
      { _M_empty_initialize(); }

      _Rb_tree(const _Compare& __comp, const allocator_type& __a)
        : _Base(__a), _M_node_count(0), _M_key_compare(__comp)
      { _M_empty_initialize(); }

      _Rb_tree(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x)
        : _Base(__x.get_allocator()), _M_node_count(0),
                 _M_key_compare(__x._M_key_compare)
      {
        if (__x._M_root() == 0)
          _M_empty_initialize();
        else
          {
            _S_color(_M_header) = _M_red;
            _M_root() = _M_copy(__x._M_root(), _M_header);
            _M_leftmost() = _S_minimum(_M_root());
            _M_rightmost() = _S_maximum(_M_root());
          }
        _M_node_count = __x._M_node_count;
      }

      ~_Rb_tree() { clear(); }

      _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>&
      operator=(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x);

    private:
      void _M_empty_initialize()
      {
        _S_color(_M_header) = _M_red;

        _M_root() = 0;
        _M_leftmost() = _M_header;
        _M_rightmost() = _M_header;
      }

    public:

      _Compare
      key_comp() const { return _M_key_compare; }

      iterator
      begin() { return _M_leftmost(); }

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

      iterator
      end() { return _M_header; }

      const_iterator
      end() const { return _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_node_count == 0; }

      size_type
      size() const { return _M_node_count; }

      size_type
      max_size() const { return size_type(-1); }

      void
      swap(_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __t)
      {
        std::swap(_M_header, __t._M_header);
        std::swap(_M_node_count, __t._M_node_count);
        std::swap(_M_key_compare, __t._M_key_compare);
      }


      pair<iterator,bool>
      insert_unique(const value_type& __x);

      iterator
      insert_equal(const value_type& __x);

      iterator
      insert_unique(iterator __position, const value_type& __x);

      iterator
      insert_equal(iterator __position, const value_type& __x);

      template<typename _InputIterator>
      void
      insert_unique(_InputIterator __first, _InputIterator __last);

      template<typename _InputIterator>
      void
      insert_equal(_InputIterator __first, _InputIterator __last);

      void
      erase(iterator __position);

      size_type
      erase(const key_type& __x);

      void
      erase(iterator __first, iterator __last);

      void
      erase(const key_type* __first, const key_type* __last);

      void
      clear()
      {
        if (_M_node_count != 0)
          {
            _M_erase(_M_root());
            _M_leftmost() = _M_header;
            _M_root() = 0;
            _M_rightmost() = _M_header;
            _M_node_count = 0;
          }
      }


      iterator
      find(const key_type& __x);

      const_iterator
      find(const key_type& __x) const;

      size_type
      count(const key_type& __x) const;

      iterator
      lower_bound(const key_type& __x);

      const_iterator
      lower_bound(const key_type& __x) const;

      iterator
      upper_bound(const key_type& __x);

      const_iterator
      upper_bound(const key_type& __x) const;

      pair<iterator,iterator>
      equal_range(const key_type& __x);

      pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const;


      bool
      __rb_verify() const;
    };

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator==(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x,
               const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __y)
    {
      return __x.size() == __y.size() &&
        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 lexicographical_compare(__x.begin(), __x.end(),
                                     __y.begin(), __y.end());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator!=(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x,
               const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __y)
    { return !(__x == __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x,
              const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __y)
    { return __y < __x; }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator<=(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x,
               const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __y)
  { return !(__y < __x); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>=(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x,
               const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __y)
  { return !(__x < __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    swap(_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x,
         _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __y)
    { __x.swap(__y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>&
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    operator=(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x)
    {
      if (this != &__x)
        {

          clear();
          _M_node_count = 0;
          _M_key_compare = __x._M_key_compare;
          if (__x._M_root() == 0)
            {
              _M_root() = 0;
              _M_leftmost() = _M_header;
              _M_rightmost() = _M_header;
            }
          else
            {
              _M_root() = _M_copy(__x._M_root(), _M_header);
              _M_leftmost() = _S_minimum(_M_root());
              _M_rightmost() = _S_maximum(_M_root());
              _M_node_count = __x._M_node_count;
            }
        }
      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    _M_insert(_Base_ptr __x_, _Base_ptr __y_, const _Val& __v)
    {
      _Link_type __x = (_Link_type) __x_;
      _Link_type __y = (_Link_type) __y_;
      _Link_type __z;

      if (__y == _M_header || __x != 0 ||
          _M_key_compare(_KeyOfValue()(__v), _S_key(__y)))
        {
          __z = _M_create_node(__v);
          _S_left(__y) = __z;

          if (__y == _M_header)
            {
              _M_root() = __z;
              _M_rightmost() = __z;
            }
          else if (__y == _M_leftmost())
            _M_leftmost() = __z;
        }
      else
        {
          __z = _M_create_node(__v);
          _S_right(__y) = __z;

          if (__y == _M_rightmost())
            _M_rightmost() = __z;
        }
      _S_parent(__z) = __y;
      _S_left(__z) = 0;
      _S_right(__z) = 0;
      _Rb_tree_rebalance(__z, _M_header->_M_parent);
      ++_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>::
    insert_equal(const _Val& __v)
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();
      while (__x != 0)
        {
          __y = __x;
          __x = _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>
    pair<typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator,
    bool>
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    insert_unique(const _Val& __v)
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();
      bool __comp = true;
      while (__x != 0)
        {
          __y = __x;
          __comp = _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_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
        return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
      return pair<iterator,bool>(__j, false);
    }


  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    insert_unique(iterator __position, const _Val& __v)
    {
      if (__position._M_node == _M_header->_M_left)
        {

          if (size() > 0 &&
              _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node)))
            return _M_insert(__position._M_node, __position._M_node, __v);

          else
            return insert_unique(__v).first;
        }
      else if (__position._M_node == _M_header)
        {

          if (_M_key_compare(_S_key(_M_rightmost()), _KeyOfValue()(__v)))
            return _M_insert(0, _M_rightmost(), __v);
          else
            return insert_unique(__v).first;
        }
      else
        {
          iterator __before = __position;
          --__before;
          if (_M_key_compare(_S_key(__before._M_node), _KeyOfValue()(__v))
              && _M_key_compare(_KeyOfValue()(__v),_S_key(__position._M_node)))
            {
              if (_S_right(__before._M_node) == 0)
                return _M_insert(0, __before._M_node, __v);
              else
                return _M_insert(__position._M_node, __position._M_node, __v);

            }
          else
            return insert_unique(__v).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>::
    insert_equal(iterator __position, const _Val& __v)
    {
      if (__position._M_node == _M_header->_M_left)
        {

          if (size() > 0 &&
              !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
            return _M_insert(__position._M_node, __position._M_node, __v);

          else
            return insert_equal(__v);
        }
      else if (__position._M_node == _M_header)
        {

          if (!_M_key_compare(_KeyOfValue()(__v), _S_key(_M_rightmost())))
            return _M_insert(0, _M_rightmost(), __v);
          else
            return insert_equal(__v);
        }
      else
        {
          iterator __before = __position;
          --__before;
          if (!_M_key_compare(_KeyOfValue()(__v), _S_key(__before._M_node))
              && !_M_key_compare(_S_key(__position._M_node),
                                 _KeyOfValue()(__v)))
            {
              if (_S_right(__before._M_node) == 0)
                return _M_insert(0, __before._M_node, __v);
              else
                return _M_insert(__position._M_node, __position._M_node, __v);

            }
          else
            return insert_equal(__v);
        }
    }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
      void
      _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>::
      insert_equal(_II __first, _II __last)
      {
        for ( ; __first != __last; ++__first)
          insert_equal(*__first);
      }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
    void
    _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>::
    insert_unique(_II __first, _II __last)
    {
      for ( ; __first != __last; ++__first)
        insert_unique(*__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 =
        (_Link_type) _Rb_tree_rebalance_for_erase(__position._M_node,
                                                  _M_header->_M_parent,
                                                  _M_header->_M_left,
                                                  _M_header->_M_right);
      destroy_node(__y);
      --_M_node_count;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::size_type
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::erase(const _Key& __x)
    {
      pair<iterator,iterator> __p = equal_range(__x);
      size_type __n = distance(__p.first, __p.second);
      erase(__p.first, __p.second);
      return __n;
    }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
    _Rb_tree<_Key,_Val,_KoV,_Compare,_Alloc>::
    _M_copy(_Link_type __x, _Link_type __p)
    {

      _Link_type __top = _M_clone_node(__x);
      __top->_M_parent = __p;

      try
        {
          if (__x->_M_right)
            __top->_M_right = _M_copy(_S_right(__x), __top);
          __p = __top;
          __x = _S_left(__x);

          while (__x != 0)
            {
              _Link_type __y = _M_clone_node(__x);
              __p->_M_left = __y;
              __y->_M_parent = __p;
              if (__x->_M_right)
                __y->_M_right = _M_copy(_S_right(__x), __y);
              __p = __y;
              __x = _S_left(__x);
            }
        }
      catch(...)
        {
          _M_erase(__top);
          throw;
        }
      return __top;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::_M_erase(_Link_type __x)
    {

      while (__x != 0)
        {
          _M_erase(_S_right(__x));
          _Link_type __y = _S_left(__x);
          destroy_node(__x);
          __x = __y;
        }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    erase(iterator __first, iterator __last)
    {
      if (__first == begin() && __last == end())
        clear();
      else
        while (__first != __last) erase(__first++);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    erase(const _Key* __first, const _Key* __last)
    {
      while (__first != __last)
        erase(*__first++);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k)
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();

      while (__x != 0)
        if (!_M_key_compare(_S_key(__x), __k))
          __y = __x, __x = _S_left(__x);
        else
          __x = _S_right(__x);

      iterator __j = iterator(__y);
      return (__j == end() || _M_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
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();

     while (__x != 0)
       {
         if (!_M_key_compare(_S_key(__x), __k))
           __y = __x, __x = _S_left(__x);
         else
           __x = _S_right(__x);
       }
     const_iterator __j = const_iterator(__y);
     return (__j == end() || _M_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);
      size_type __n = distance(__p.first, __p.second);
      return __n;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    lower_bound(const _Key& __k)
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();

      while (__x != 0)
        if (!_M_key_compare(_S_key(__x), __k))
          __y = __x, __x = _S_left(__x);
        else
          __x = _S_right(__x);

      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::const_iterator
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    lower_bound(const _Key& __k) const
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();

      while (__x != 0)
        if (!_M_key_compare(_S_key(__x), __k))
          __y = __x, __x = _S_left(__x);
        else
          __x = _S_right(__x);

      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    upper_bound(const _Key& __k)
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();

      while (__x != 0)
        if (_M_key_compare(__k, _S_key(__x)))
          __y = __x, __x = _S_left(__x);
        else
          __x = _S_right(__x);

      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::const_iterator
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    upper_bound(const _Key& __k) const
    {
      _Link_type __y = _M_header;
      _Link_type __x = _M_root();

      while (__x != 0)
        if (_M_key_compare(__k, _S_key(__x)))
          __y = __x, __x = _S_left(__x);
        else
          __x = _S_right(__x);

      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline
    pair<typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator,
                                                                   typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator>
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
    equal_range(const _Key& __k)
    { return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k)); }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Compare, typename _Alloc>
  inline
  pair<typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator,
                                                                typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator>
  _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>
  ::equal_range(const _Key& __k) const
  {
    return pair<const_iterator,const_iterator>(lower_bound(__k),
                                               upper_bound(__k));
  }

  inline int
  __black_count(_Rb_tree_node_base* __node, _Rb_tree_node_base* __root)
  {
    if (__node == 0)
      return 0;
    int __sum = 0;
    do
      {
        if (__node->_M_color == _M_black)
          ++__sum;
        if (__node == __root)
          break;
        __node = __node->_M_parent;
      }
    while (1);
    return __sum;
  }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    bool
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
    {
    if (_M_node_count == 0 || begin() == end())
      return _M_node_count == 0 && begin() == end() &&
        _M_header->_M_left == _M_header && _M_header->_M_right == _M_header;

    int __len = __black_count(_M_leftmost(), _M_root());
    for (const_iterator __it = begin(); __it != end(); ++__it)
      {
        _Link_type __x = (_Link_type) __it._M_node;
        _Link_type __L = _S_left(__x);
        _Link_type __R = _S_right(__x);

        if (__x->_M_color == _M_red)
          if ((__L && __L->_M_color == _M_red)
              || (__R && __R->_M_color == _M_red))
            return false;

        if (__L && _M_key_compare(_S_key(__x), _S_key(__L)))
          return false;
        if (__R && _M_key_compare(_S_key(__R), _S_key(__x)))
          return false;

        if (!__L && !__R && __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;
    }
}
# 67 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/map" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
#define __GLIBCPP_INTERNAL_MAP_H 



namespace std
{
# 89 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
  template <typename _Key, typename _Tp, typename _Compare = less<_Key>,
            typename _Alloc = allocator<pair<const _Key, _Tp> > >
    class map
  {

   
   

  public:
    typedef _Key key_type;
    typedef _Tp mapped_type;
    typedef pair<const _Key, _Tp> value_type;
    typedef _Compare key_compare;

    class value_compare
      : public 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 _Rb_tree<key_type, value_type,
                     _Select1st<value_type>, key_compare, _Alloc> _Rep_type;

    _Rep_type _M_t;

  public:


    typedef typename _Rep_type::allocator_type allocator_type;
    typedef typename _Rep_type::reference reference;
    typedef typename _Rep_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::pointer pointer;
    typedef typename _Rep_type::const_pointer const_pointer;
    typedef typename _Rep_type::reverse_iterator reverse_iterator;
    typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
# 144 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    map() : _M_t(_Compare(), allocator_type()) { }





    explicit
    map(const _Compare& __comp, const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 161 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    map(const map& __x)
      : _M_t(__x._M_t) { }
# 173 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    template <typename _InputIterator>
      map(_InputIterator __first, _InputIterator __last)
      : _M_t(_Compare(), allocator_type())
      { _M_t.insert_unique(__first, __last); }
# 189 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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.insert_unique(__first, __last); }
# 211 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    map&
    operator=(const map& __x)
    {
      _M_t = __x._M_t;
      return *this;
    }


    allocator_type
    get_allocator() const { return _M_t.get_allocator(); }






    iterator
    begin() { return _M_t.begin(); }






    const_iterator
    begin() const { return _M_t.begin(); }





    iterator
    end() { return _M_t.end(); }






    const_iterator
    end() const { return _M_t.end(); }





    reverse_iterator
    rbegin() { return _M_t.rbegin(); }






    const_reverse_iterator
    rbegin() const { return _M_t.rbegin(); }






    reverse_iterator
    rend() { return _M_t.rend(); }






    const_reverse_iterator
    rend() const { return _M_t.rend(); }



    bool
    empty() const { return _M_t.empty(); }


    size_type
    size() const { return _M_t.size(); }


    size_type
    max_size() const { return _M_t.max_size(); }
# 310 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 338 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    pair<iterator,bool>
    insert(const value_type& __x)
    { return _M_t.insert_unique(__x); }
# 362 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    iterator
    insert(iterator position, const value_type& __x)
    { return _M_t.insert_unique(position, __x); }
# 374 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    template <typename _InputIterator>
      void
      insert(_InputIterator __first, _InputIterator __last)
      { _M_t.insert_unique(__first, __last); }
# 388 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    void
    erase(iterator __position) { _M_t.erase(__position); }
# 402 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    size_type
    erase(const key_type& __x) { return _M_t.erase(__x); }
# 415 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    void
    erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
# 429 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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()); }
# 467 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    iterator
    find(const key_type& __x) { return _M_t.find(__x); }
# 481 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    const_iterator
    find(const key_type& __x) const { return _M_t.find(__x); }
# 492 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    size_type
    count(const key_type& __x) const
    { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 507 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    iterator
    lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); }
# 521 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    const_iterator
    lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); }
# 531 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    iterator
    upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); }
# 542 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    const_iterator
    upper_bound(const key_type& __x) const
    { return _M_t.upper_bound(__x); }
# 561 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    pair<iterator,iterator>
    equal_range(const key_type& __x)
    { return _M_t.equal_range(__x); }
# 580 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_map.h" 3
    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>&);
  };
# 603 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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; }
# 620 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
}
# 68 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/map" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
#define __GLIBCPP_INTERNAL_MULTIMAP_H 



namespace std
{


  template <typename _Key, typename _Tp,
            typename _Compare = less<_Key>,
            typename _Alloc = allocator<pair<const _Key, _Tp> > >
  class multimap;

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

  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);
# 104 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class multimap
  {

   
   

  public:
    typedef _Key key_type;
    typedef _Tp mapped_type;
    typedef pair<const _Key, _Tp> value_type;
    typedef _Compare key_compare;

    class value_compare
      : public 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 _Rb_tree<key_type, value_type,
                    _Select1st<value_type>, key_compare, _Alloc> _Rep_type;

    _Rep_type _M_t;

  public:


    typedef typename _Rep_type::allocator_type allocator_type;
    typedef typename _Rep_type::reference reference;
    typedef typename _Rep_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::pointer pointer;
    typedef typename _Rep_type::const_pointer const_pointer;
    typedef typename _Rep_type::reverse_iterator reverse_iterator;
    typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;







    multimap() : _M_t(_Compare(), allocator_type()) { }





    explicit
    multimap(const _Compare& __comp, const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 174 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    multimap(const multimap& __x)
      : _M_t(__x._M_t) { }
# 186 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    template <typename _InputIterator>
      multimap(_InputIterator __first, _InputIterator __last)
        : _M_t(_Compare(), allocator_type())
        { _M_t.insert_equal(__first, __last); }
# 202 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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.insert_equal(__first, __last); }
# 225 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    multimap&
    operator=(const multimap& __x)
    {
      _M_t = __x._M_t;
      return *this;
    }


    allocator_type
    get_allocator() const { return _M_t.get_allocator(); }






    iterator
    begin() { return _M_t.begin(); }






    const_iterator
    begin() const { return _M_t.begin(); }





    iterator
    end() { return _M_t.end(); }






    const_iterator
    end() const { return _M_t.end(); }






    reverse_iterator
    rbegin() { return _M_t.rbegin(); }






    const_reverse_iterator
    rbegin() const { return _M_t.rbegin(); }






    reverse_iterator
    rend() { return _M_t.rend(); }






    const_reverse_iterator
    rend() const { return _M_t.rend(); }



    bool
    empty() const { return _M_t.empty(); }


    size_type
    size() const { return _M_t.size(); }


    size_type
    max_size() const { return _M_t.max_size(); }
# 325 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    iterator
    insert(const value_type& __x) { return _M_t.insert_equal(__x); }
# 348 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    iterator
    insert(iterator __position, const value_type& __x)
    { return _M_t.insert_equal(__position, __x); }
# 360 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    template <typename _InputIterator>
      void
      insert(_InputIterator __first, _InputIterator __last)
      { _M_t.insert_equal(__first, __last); }
# 374 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    void
    erase(iterator __position) { _M_t.erase(__position); }
# 388 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    size_type
    erase(const key_type& __x) { return _M_t.erase(__x); }
# 401 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    void
    erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
# 415 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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()); }
# 454 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    iterator
    find(const key_type& __x) { return _M_t.find(__x); }
# 468 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
# 490 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    iterator
    lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); }
# 504 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
# 537 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    pair<iterator,iterator>
    equal_range(const key_type& __x) { return _M_t.equal_range(__x); }
# 553 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_multimap.h" 3
    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>&);
  };
# 575 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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;
    }
# 594 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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); }
}
# 69 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/map" 2 3
# 29 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataDictionary.h" 2

# 1 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataObjectBase.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataObjectBase.h"
#define MetaDataObjectBase_h_h 
# 32 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataObjectBase.h"
namespace itk {
# 41 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataObjectBase.h"
  class MetaDataObjectBase : public LightObject
  {
    public:

      typedef MetaDataObjectBase Self;
      typedef LightObject Superclass;
      typedef SmartPointer<Self> Pointer;
      typedef SmartPointer<const Self> ConstPointer;



      virtual const char *GetNameOfClass() const {return "MetaDataObjectBase";};





      virtual const char * GetMetaDataObjectTypeName(void) const;




      virtual const std::type_info & GetMetaDataObjectTypeInfo(void) const;




      virtual void Print(std::ostream& os) const;
    protected:


      static Pointer New(void);



      virtual ~MetaDataObjectBase();
      MetaDataObjectBase();
    private:

      MetaDataObjectBase(const Self &);
      void operator=(const Self&);
  };
}
# 31 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataDictionary.h" 2

namespace itk
{
# 42 "/tmp/installed/include/InsightToolkit/Common/itkMetaDataDictionary.h"
  class MetaDataDictionary
    {
      public:
        typedef MetaDataDictionary Self;




        virtual void Print(std::ostream& os) const;



        class MetaDataDictionaryMapType
          : public std::map<std::string, MetaDataObjectBase::Pointer>
        {
        };

        typedef MetaDataDictionaryMapType::iterator Iterator;
        typedef MetaDataDictionaryMapType::const_iterator ConstIterator;


        MetaDataDictionary();

        MetaDataDictionary(const MetaDataDictionary&);

        void operator=(const MetaDataDictionary&);


        virtual ~MetaDataDictionary();




      std::vector<std::string> GetKeys() const;





        MetaDataObjectBase::Pointer &operator [](const std::string &);
        const MetaDataObjectBase * operator [](const std::string &) const;
        bool HasKey (const std::string &);



        Iterator Begin();
        ConstIterator Begin() const;


        Iterator End();
        ConstIterator End() const;


        Iterator Find(const std::string & key);
        ConstIterator Find(const std::string & key) const;


    private:
        MetaDataDictionaryMapType *m_Dictionary;
    };
}
# 27 "/tmp/installed/include/InsightToolkit/Common/itkObject.h" 2
namespace itk
{
class SubjectImplementation;
class Command;
# 44 "/tmp/installed/include/InsightToolkit/Common/itkObject.h"
class Object: public LightObject
{
public:

  typedef Object Self;
  typedef LightObject Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  static Pointer New();






  virtual LightObject::Pointer CreateAnother() const;


  virtual const char *GetNameOfClass() const {return "Object";};


  virtual void DebugOn() const;


  virtual void DebugOff() const;


  bool GetDebug() const;


  void SetDebug(bool debugFlag) const;


  virtual unsigned long GetMTime() const;



  virtual void Modified() const;


  virtual void Register() const;


  virtual void UnRegister() const;


  virtual void SetReferenceCount(int);



  static void SetGlobalWarningDisplay(bool flag);
  static bool GetGlobalWarningDisplay();
  static void GlobalWarningDisplayOn()
    { Object::SetGlobalWarningDisplay(true); }
  static void GlobalWarningDisplayOff()
    { Object::SetGlobalWarningDisplay(false); }
# 111 "/tmp/installed/include/InsightToolkit/Common/itkObject.h"
  unsigned long AddObserver(const EventObject & event, Command *);






  Command* GetCommand(unsigned long tag);


  void InvokeEvent( const EventObject & );



  void InvokeEvent( const EventObject & ) const;


  void RemoveObserver(unsigned long tag);


  void RemoveAllObservers();


  bool HasObserver( const EventObject & event ) const;





  MetaDataDictionary & GetMetaDataDictionary(void);




  const MetaDataDictionary & GetMetaDataDictionary(void) const;




  void SetMetaDataDictionary(const MetaDataDictionary & rhs);


protected:
  Object();
  virtual ~Object();





  virtual void PrintSelf(std::ostream& os, Indent indent) const;

  bool PrintObservers(std::ostream& os, Indent indent) const;

private:
  Object(const Self&);
  void operator=(const Self&);


  mutable bool m_Debug;


  mutable TimeStamp m_MTime;


  static bool m_GlobalWarningDisplay;



  SubjectImplementation* m_SubjectImplementation;







  mutable MetaDataDictionary * m_MetaDataDictionary;
};

}
# 24 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointerForwardReference.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointerForwardReference.h"
#define __itkSmartPointerForwardReference_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkWeakPointer.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkWeakPointer.h"
#define __itkWeakPointer_h 




namespace itk
{
# 42 "/tmp/installed/include/InsightToolkit/Common/itkWeakPointer.h"
template <class TObjectType>
class WeakPointer
{
public:

  typedef TObjectType ObjectType;


  WeakPointer ()
    { m_Pointer = 0; }


  WeakPointer (const WeakPointer<ObjectType> &p):
    m_Pointer(p.m_Pointer) { }


  WeakPointer (ObjectType *p):
    m_Pointer(p) { }


  ~WeakPointer ()
    { m_Pointer = 0; }


  ObjectType *operator -> () const
    { return m_Pointer; }


  operator ObjectType * () const
    { return m_Pointer; }


  template <typename R>
  bool operator == (R r) const
    {
    return (m_Pointer == (ObjectType*)r);
    }
  template <typename R>
  bool operator != (R r) const
    {
    return (m_Pointer != (ObjectType*)r);
    }


  ObjectType *GetPointer () const
    { return m_Pointer; }


  bool operator < (const WeakPointer &r) const
    { return (void*)m_Pointer < (void*) r.m_Pointer; }


  bool operator > (const WeakPointer &r) const
    { return (void*)m_Pointer > (void*) r.m_Pointer; }


  bool operator <= (const WeakPointer &r) const
    { return (void*)m_Pointer <= (void*) r.m_Pointer; }


  bool operator >= (const WeakPointer &r) const
    { return (void*)m_Pointer >= (void*) r.m_Pointer; }


  WeakPointer &operator = (const WeakPointer &r)
    { return this->operator = (r.GetPointer()); }


  WeakPointer &operator = (ObjectType *r)
   {
    m_Pointer = r;
    return *this;
    }


  ObjectType *Print (std::ostream& os) const
    {

    (*m_Pointer).Print(os);
    return m_Pointer;
    }

private:

  ObjectType* m_Pointer;
};


template <typename T>
std::ostream& operator<< (std::ostream& os, WeakPointer<T> p)
{
  p.Print(os);
  return os;
}

}
# 22 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointerForwardReference.h" 2



namespace itk
{
# 47 "/tmp/installed/include/InsightToolkit/Common/itkSmartPointerForwardReference.h"
template <class T>
class SmartPointerForwardReference
{
public:

  SmartPointerForwardReference ()
    {m_Pointer = 0;}


  SmartPointerForwardReference (const SmartPointerForwardReference<T> &p);


  SmartPointerForwardReference (const WeakPointer<T> &p);


  SmartPointerForwardReference (T *p);


  ~SmartPointerForwardReference ();


  T *operator -> () const;


  operator T * () const;


  T *GetPointer () const;


  bool operator < (const SmartPointerForwardReference &r);


  bool operator > (const SmartPointerForwardReference &r);


  bool operator <= (const SmartPointerForwardReference &r);


  bool operator >= (const SmartPointerForwardReference &r);


  SmartPointerForwardReference &operator = (const SmartPointerForwardReference &r);


  SmartPointerForwardReference &operator = (const WeakPointer<T> &r);


  SmartPointerForwardReference &operator = (T *r);


  T *Print (std::ostream& os) const;

private:

  T* m_Pointer;

  void Register();
  void UnRegister();

};

  template <typename T>
  std::ostream& operator<< (std::ostream& os, SmartPointerForwardReference<T> p)
  {
    p.Print(os);
    return os;
  }

}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h" 2

# 1 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 1
# 27 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h" 2

namespace itk
{

class ProcessObject;
class DataObject;




class DataObjectError : public ExceptionObject
{
public:


  DataObjectError();


  virtual ~DataObjectError() throw() {}


  DataObjectError(const char *file, unsigned int lineNumber);


  DataObjectError(const std::string& file, unsigned int lineNumber);


  DataObjectError(const DataObjectError &orig);


  DataObjectError& operator=( const DataObjectError& orig);


  virtual const char *GetNameOfClass() const {return "DataObjectError";};


  void SetDataObject(DataObject *dobj);


  DataObject* GetDataObject();

protected:




  virtual void PrintSelf(std::ostream& os, Indent indent) const;

private:
  DataObject *m_DataObject;
};





class InvalidRequestedRegionError : public DataObjectError
{
 public:

  InvalidRequestedRegionError();


  virtual ~InvalidRequestedRegionError() throw() {}


  InvalidRequestedRegionError(const char *file, unsigned int lineNumber);


  InvalidRequestedRegionError(const std::string& file, unsigned int lineNumber);


  InvalidRequestedRegionError(const InvalidRequestedRegionError &orig);


  InvalidRequestedRegionError& operator=( const InvalidRequestedRegionError& orig);


  virtual const char *GetNameOfClass() const {return "InvalidRequestedRegionError";};

protected:




  virtual void PrintSelf(std::ostream& os, Indent indent) const;

};
# 261 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
class DataObject : public Object
{
public:

  typedef DataObject Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  virtual const char *GetNameOfClass() const {return "DataObject";};






  void DisconnectPipeline();
# 292 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  SmartPointerForwardReference<ProcessObject> GetSource() const;


  unsigned int GetSourceOutputIndex() const;



  virtual void Initialize();



  virtual void SetReleaseDataFlag (const bool _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h" ", line " << 303 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "ReleaseDataFlag" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_ReleaseDataFlag != _arg) { this->m_ReleaseDataFlag = _arg; this->Modified(); } };
  virtual bool GetReleaseDataFlag () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h" ", line " << 304 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "ReleaseDataFlag" " of " << this->m_ReleaseDataFlag << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_ReleaseDataFlag; };
  virtual void ReleaseDataFlagOn () { this->SetReleaseDataFlag(true);} virtual void ReleaseDataFlagOff () { this->SetReleaseDataFlag(false);};




  static void SetGlobalReleaseDataFlag(const bool val);
  static bool GetGlobalReleaseDataFlag();
  void GlobalReleaseDataFlagOn()
    {this->SetGlobalReleaseDataFlag(true);}
  void GlobalReleaseDataFlagOff()
    {this->SetGlobalReleaseDataFlag(false);}





  void ReleaseData();



  bool ShouldIReleaseData() const;


  bool GetDataReleased() const
    {return m_DataReleased;}
# 341 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  virtual void Update();
# 352 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  virtual void UpdateOutputInformation();



  virtual void PropagateRequestedRegion() throw (InvalidRequestedRegionError);
  virtual void UpdateOutputData();




  virtual void ResetPipeline();



  void SetPipelineMTime(unsigned long time)
    {m_PipelineMTime = time;}
  virtual unsigned long GetPipelineMTime () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h" ", line " << 368 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "PipelineMTime" " of " << this->m_PipelineMTime << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_PipelineMTime; };


  virtual unsigned long GetUpdateMTime() const;
# 381 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  virtual void PrepareForNewData()
    {this->Initialize();}





  void DataHasBeenGenerated();





  virtual void SetRequestedRegionToLargestPossibleRegion() {};
# 405 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion()
    { return false; }
# 420 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  virtual bool VerifyRequestedRegion() { return true; };
# 431 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  virtual void CopyInformation(const DataObject*) {};






  virtual void SetRequestedRegion(DataObject *) {};

protected:
  DataObject();
  ~DataObject();
  void PrintSelf(std::ostream& os, Indent indent) const;


  virtual void PropagateResetPipeline();

private:
  DataObject(const Self&);
  void operator=(const Self&);


  mutable WeakPointer<ProcessObject> m_Source;
  mutable unsigned int m_SourceOutputIndex;


  TimeStamp m_UpdateMTime;

  bool m_ReleaseDataFlag;
  bool m_DataReleased;



  unsigned long m_PipelineMTime;


  static bool m_GlobalReleaseDataFlag;





  bool ConnectSource(ProcessObject *s, unsigned int idx) const;
# 483 "/tmp/installed/include/InsightToolkit/Common/itkDataObject.h"
  bool DisconnectSource(ProcessObject *s, unsigned int idx) const;


  friend class ProcessObject;
  friend class DataObjectError;
  };

}
# 24 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
#define __itkProcessObject_h 



# 1 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h"
#define __itkMultiThreader_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkMutexLock.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkMutexLock.h"
#define __itkMutexLock_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactory.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactory.h"
#define __itkObjectFactory_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactoryBase.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactoryBase.h"
#define __itkObjectFactoryBase_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkCreateObjectFunction.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkCreateObjectFunction.h"
#define __itkCreateObjectFunction_h 



namespace itk
{






class CreateObjectFunctionBase: public Object
{
public:

  typedef CreateObjectFunctionBase Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;



  virtual SmartPointer<LightObject> CreateObject() = 0;

protected:
  CreateObjectFunctionBase() {}
  ~CreateObjectFunctionBase() {}

private:
  CreateObjectFunctionBase(const Self&);
  void operator=(const Self&);
};
# 59 "/tmp/installed/include/InsightToolkit/Common/itkCreateObjectFunction.h"
template <class T>
class CreateObjectFunction : public CreateObjectFunctionBase
{
public:

  typedef CreateObjectFunction Self;
  typedef SmartPointer<Self> Pointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = new Self; smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual LightObject::Pointer CreateAnother(void) const { LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };
  LightObject::Pointer CreateObject() { return T::New().GetPointer(); }

protected:
  CreateObjectFunction() {}
  ~CreateObjectFunction() {}

private:
  CreateObjectFunction(const Self&);
  void operator=(const Self&);
};

}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactoryBase.h" 2
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/list" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/list" 3
#define _CPP_LIST 1

       
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/list" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 1 3
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/exception_defines.h" 3
#define __throw_exception_again throw
# 35 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 67 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/list" 2 3




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
#define __GLIBCPP_INTERNAL_LIST_H 



namespace std
{






  struct _List_node_base
  {
    _List_node_base* _M_next;
    _List_node_base* _M_prev;
  };


  template<typename _Tp>
    struct _List_node : public _List_node_base
  {
    _Tp _M_data;
  };
# 97 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
  struct _List_iterator_base
  {
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef bidirectional_iterator_tag iterator_category;


    _List_node_base* _M_node;

    _List_iterator_base(_List_node_base* __x)
    : _M_node(__x)
    { }

    _List_iterator_base()
    { }


    void
    _M_incr()
    { _M_node = _M_node->_M_next; }


    void
    _M_decr()
    { _M_node = _M_node->_M_prev; }

    bool
    operator==(const _List_iterator_base& __x) const
    { return _M_node == __x._M_node; }

    bool
    operator!=(const _List_iterator_base& __x) const
    { return _M_node != __x._M_node; }
  };
# 142 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
  template<typename _Tp, typename _Ref, typename _Ptr>
    struct _List_iterator : public _List_iterator_base
  {
    typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator;
    typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
    typedef _List_iterator<_Tp,_Ref,_Ptr> _Self;

    typedef _Tp value_type;
    typedef _Ptr pointer;
    typedef _Ref reference;
    typedef _List_node<_Tp> _Node;

    _List_iterator(_Node* __x)
    : _List_iterator_base(__x)
    { }

    _List_iterator()
    { }

    _List_iterator(const iterator& __x)
    : _List_iterator_base(__x._M_node)
    { }

    reference
    operator*() const
    { return static_cast<_Node*>(_M_node)->_M_data; }


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

    _Self&
    operator++()
    {
      this->_M_incr();
      return *this;
    }

    _Self
    operator++(int)
    {
      _Self __tmp = *this;
      this->_M_incr();
      return __tmp;
    }

    _Self&
    operator--()
    {
      this->_M_decr();
      return *this;
    }

    _Self
    operator--(int)
    {
      _Self __tmp = *this;
      this->_M_decr();
      return __tmp;
    }
  };
# 212 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
  template<typename _Tp, typename _Allocator, bool _IsStatic>
    class _List_alloc_base
  {
  public:
    typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
            allocator_type;

    allocator_type
    get_allocator() const { return _M_node_allocator; }

    _List_alloc_base(const allocator_type& __a)
    : _M_node_allocator(__a)
    { }

  protected:
    _List_node<_Tp>*
    _M_get_node()
    { return _M_node_allocator.allocate(1); }

    void
    _M_put_node(_List_node<_Tp>* __p)
    { _M_node_allocator.deallocate(__p, 1); }
# 247 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    typename _Alloc_traits<_List_node<_Tp>, _Allocator>::allocator_type
             _M_node_allocator;

    _List_node<_Tp>* _M_node;
  };


  template<typename _Tp, typename _Allocator>
    class _List_alloc_base<_Tp, _Allocator, true>
  {
  public:
    typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
            allocator_type;

    allocator_type
    get_allocator() const { return allocator_type(); }

    _List_alloc_base(const allocator_type&)
    { }

  protected:


    typedef typename _Alloc_traits<_List_node<_Tp>, _Allocator>::_Alloc_type
            _Alloc_type;

    _List_node<_Tp>*
    _M_get_node()
    { return _Alloc_type::allocate(1); }

    void
    _M_put_node(_List_node<_Tp>* __p)
    { _Alloc_type::deallocate(__p, 1); }

    _List_node<_Tp>* _M_node;
  };







  template <typename _Tp, typename _Alloc>
    class _List_base
    : public _List_alloc_base<_Tp, _Alloc,
                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
  {
  public:
    typedef _List_alloc_base<_Tp, _Alloc,
                             _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
            _Base;
    typedef typename _Base::allocator_type allocator_type;

    _List_base(const allocator_type& __a)
    : _Base(__a)
    {
      _M_node = _M_get_node();
      _M_node->_M_next = _M_node;
      _M_node->_M_prev = _M_node;
    }


    ~_List_base()
    {
      __clear();
      _M_put_node(_M_node);
    }

    void
    __clear();
  };
# 365 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc = allocator<_Tp> >
    class list : protected _List_base<_Tp, _Alloc>
  {

   

    typedef _List_base<_Tp, _Alloc> _Base;

  public:
    typedef _Tp value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator;
    typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef typename _Base::allocator_type allocator_type;

  protected:

    typedef _List_node<_Tp> _Node;







    using _Base::_M_node;
    using _Base::_M_put_node;
    using _Base::_M_get_node;
# 408 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    _Node*
    _M_create_node(const value_type& __x)
    {
      _Node* __p = _M_get_node();
      try {
        _Construct(&__p->_M_data, __x);
      }
      catch(...)
      {
        _M_put_node(__p);
        throw;
      }
      return __p;
    }







    _Node*
    _M_create_node()
    {
      _Node* __p = _M_get_node();
      try {
        _Construct(&__p->_M_data);
      }
      catch(...)
      {
        _M_put_node(__p);
        throw;
      }
      return __p;
    }

  public:





    explicit
    list(const allocator_type& __a = allocator_type())
    : _Base(__a) { }
# 461 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    list(size_type __n, const value_type& __value,
         const allocator_type& __a = allocator_type())
      : _Base(__a)
      { this->insert(begin(), __n, __value); }
# 473 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    explicit
    list(size_type __n)
      : _Base(allocator_type())
      { this->insert(begin(), __n, value_type()); }
# 485 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    list(const list& __x)
      : _Base(__x.get_allocator())
      { this->insert(begin(), __x.begin(), __x.end()); }
# 502 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    template<typename _InputIterator>
      list(_InputIterator __first, _InputIterator __last,
           const allocator_type& __a = allocator_type())
      : _Base(__a)
      { this->insert(begin(), __first, __last); }






    ~list() { }
# 522 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    list&
    operator=(const list& __x);
# 535 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); }
# 550 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    template<typename _InputIterator>
      void
      assign(_InputIterator __first, _InputIterator __last)
      {

        typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
        _M_assign_dispatch(__first, __last, _Integral());
      }


    allocator_type
    get_allocator() const { return _Base::get_allocator(); }






    iterator
    begin() { return static_cast<_Node*>(_M_node->_M_next); }





    const_iterator
    begin() const { return static_cast<_Node*>(_M_node->_M_next); }





    iterator
    end() { return _M_node; }





    const_iterator
    end() const { return _M_node; }





    reverse_iterator
    rbegin() { return reverse_iterator(end()); }





    const_reverse_iterator
    rbegin() const { return const_reverse_iterator(end()); }






    reverse_iterator
    rend() { return reverse_iterator(begin()); }






    const_reverse_iterator
    rend() const
    { return const_reverse_iterator(begin()); }





    bool
    empty() const { return _M_node->_M_next == _M_node; }


    size_type
    size() const { return distance(begin(), end()); }


    size_type
    max_size() const { return size_type(-1); }
# 648 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    resize(size_type __new_size, const value_type& __x);
# 660 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    resize(size_type __new_size) { this->resize(__new_size, value_type()); }






    reference
    front() { return *begin(); }





    const_reference
    front() const { return *begin(); }





    reference
    back() { return *(--end()); }





    const_reference
    back() const { return *(--end()); }
# 702 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    push_front(const value_type& __x) { this->insert(begin(), __x); }
# 733 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    pop_front() { this->erase(begin()); }
# 745 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    push_back(const value_type& __x) { this->insert(end(), __x); }
# 776 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    pop_back()
    {
      iterator __tmp = end();
      this->erase(--__tmp);
    }
# 794 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    iterator
    insert(iterator __position, const value_type& __x);
# 829 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    insert(iterator __pos, size_type __n, const value_type& __x)
    { _M_fill_insert(__pos, __n, __x); }
# 845 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    template<typename _InputIterator>
      void
      insert(iterator __pos, _InputIterator __first, _InputIterator __last)
      {

        typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
        _M_insert_dispatch(__pos, __first, __last, _Integral());
      }
# 870 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    iterator
    erase(iterator __position);
# 892 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    iterator
    erase(iterator __first, iterator __last)
    {
      while (__first != __last)
        erase(__first++);
      return __last;
    }
# 909 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
    void
    swap(list& __x) { std::swap(_M_node, __x._M_node); }







    void
    clear() { _Base::__clear(); }





    void
    splice(iterator __position, list& __x)
    {
      if (!__x.empty())
        this->_M_transfer(__position, __x.begin(), __x.end());
    }




    void
    splice(iterator __position, list&, iterator __i)
    {
      iterator __j = __i;
      ++__j;
      if (__position == __i || __position == __j) return;
      this->_M_transfer(__position, __i, __j);
    }




    void
    splice(iterator __position, list&, iterator __first, iterator __last)
    {
      if (__first != __last)
        this->_M_transfer(__position, __first, __last);
    }




    void
    remove(const _Tp& __value);




    template<typename _Predicate>
      void
      remove_if(_Predicate);




    void
    unique();




    template<typename _BinaryPredicate>
      void
      unique(_BinaryPredicate);




    void
    merge(list& __x);




    template<typename _StrictWeakOrdering>
      void
      merge(list&, _StrictWeakOrdering);




    void
    reverse() { __List_base_reverse(this->_M_node); }




    void
    sort();




    template<typename _StrictWeakOrdering>
      void
      sort(_StrictWeakOrdering);

  protected:



    template<typename _Integer>
      void
      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
      {
        _M_fill_assign(static_cast<size_type>(__n),
                       static_cast<value_type>(__val));
      }


    template<typename _InputIter>
      void
      _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type);



    void
    _M_fill_assign(size_type __n, const value_type& __val);





    template<typename _Integer>
      void
      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
                         __true_type)
      {
        _M_fill_insert(__pos, static_cast<size_type>(__n),
                       static_cast<value_type>(__x));
      }


    template<typename _InputIterator>
      void
      _M_insert_dispatch(iterator __pos,
                         _InputIterator __first, _InputIterator __last,
                         __false_type)
      {
        for ( ; __first != __last; ++__first)
          insert(__pos, *__first);
      }



    void
    _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
    {
      for ( ; __n > 0; --__n)
        insert(__pos, __x);
    }



    void
    _M_transfer(iterator __position, iterator __first, iterator __last)
    {
      if (__position != __last) {

        __last._M_node->_M_prev->_M_next = __position._M_node;
        __first._M_node->_M_prev->_M_next = __last._M_node;
        __position._M_node->_M_prev->_M_next = __first._M_node;


        _List_node_base* __tmp = __position._M_node->_M_prev;
        __position._M_node->_M_prev = __last._M_node->_M_prev;
        __last._M_node->_M_prev = __first._M_node->_M_prev;
        __first._M_node->_M_prev = __tmp;
      }
    }
  };
# 1098 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
  inline bool
    operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
    {
      typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;
      const_iterator __end1 = __x.end();
      const_iterator __end2 = __y.end();

      const_iterator __i1 = __x.begin();
      const_iterator __i2 = __y.begin();
      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
        ++__i1;
        ++__i2;
      }
      return __i1 == __end1 && __i2 == __end2;
    }
# 1126 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
    {
      return lexicographical_compare(__x.begin(), __x.end(),
                                     __y.begin(), __y.end());
    }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator<=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Alloc>
    inline void
    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
    { __x.swap(__y); }
}
# 72 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/list" 2 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/list.tcc" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/list.tcc" 3
#define __GLIBCPP_INTERNAL_LIST_TCC 

namespace std
{
  template<typename _Tp, typename _Alloc>
    void
    _List_base<_Tp,_Alloc>::
    __clear()
    {
      typedef _List_node<_Tp> _Node;
      _Node* __cur = static_cast<_Node*>(_M_node->_M_next);
      while (__cur != _M_node)
      {
        _Node* __tmp = __cur;
        __cur = static_cast<_Node*>(__cur->_M_next);
        _Destroy(&__tmp->_M_data);
        _M_put_node(__tmp);
      }
      _M_node->_M_next = _M_node;
      _M_node->_M_prev = _M_node;
    }

  template<typename _Tp, typename _Alloc>
    typename list<_Tp,_Alloc>::iterator
    list<_Tp,_Alloc>::
    insert(iterator __position, const value_type& __x)
    {
      _Node* __tmp = _M_create_node(__x);
      __tmp->_M_next = __position._M_node;
      __tmp->_M_prev = __position._M_node->_M_prev;
      __position._M_node->_M_prev->_M_next = __tmp;
      __position._M_node->_M_prev = __tmp;
      return __tmp;
    }

  template<typename _Tp, typename _Alloc>
    typename list<_Tp,_Alloc>::iterator
    list<_Tp,_Alloc>::
    erase(iterator __position)
    {
      _List_node_base* __next_node = __position._M_node->_M_next;
      _List_node_base* __prev_node = __position._M_node->_M_prev;
      _Node* __n = static_cast<_Node*>(__position._M_node);
      __prev_node->_M_next = __next_node;
      __next_node->_M_prev = __prev_node;
      _Destroy(&__n->_M_data);
      _M_put_node(__n);
      return iterator(static_cast<_Node*>(__next_node));
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp,_Alloc>::
    resize(size_type __new_size, const value_type& __x)
    {
      iterator __i = begin();
      size_type __len = 0;
      for ( ; __i != end() && __len < __new_size; ++__i, ++__len)
        ;
      if (__len == __new_size)
        erase(__i, end());
      else
        insert(end(), __new_size - __len, __x);
    }

  template<typename _Tp, typename _Alloc>
    list<_Tp,_Alloc>&
    list<_Tp,_Alloc>::
    operator=(const list& __x)
    {
      if (this != &__x)
      {
        iterator __first1 = begin();
        iterator __last1 = end();
        const_iterator __first2 = __x.begin();
        const_iterator __last2 = __x.end();
        while (__first1 != __last1 && __first2 != __last2)
          *__first1++ = *__first2++;
        if (__first2 == __last2)
          erase(__first1, __last1);
        else
          insert(__last1, __first2, __last2);
      }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp,_Alloc>::
    _M_fill_assign(size_type __n, const value_type& __val)
    {
      iterator __i = begin();
      for ( ; __i != end() && __n > 0; ++__i, --__n)
        *__i = __val;
      if (__n > 0)
        insert(end(), __n, __val);
      else
        erase(__i, end());
    }

  template<typename _Tp, typename _Alloc>
    template <typename _InputIter>
      void
      list<_Tp,_Alloc>::
      _M_assign_dispatch(_InputIter __first2, _InputIter __last2, __false_type)
      {
        iterator __first1 = begin();
        iterator __last1 = end();
        for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
          *__first1 = *__first2;
        if (__first2 == __last2)
          erase(__first1, __last1);
        else
          insert(__last1, __first2, __last2);
      }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp,_Alloc>::
    remove(const value_type& __value)
    {
      iterator __first = begin();
      iterator __last = end();
      while (__first != __last)
      {
        iterator __next = __first;
        ++__next;
        if (*__first == __value)
          erase(__first);
        __first = __next;
      }
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp,_Alloc>::
    unique()
    {
      iterator __first = begin();
      iterator __last = end();
      if (__first == __last) return;
      iterator __next = __first;
      while (++__next != __last)
      {
        if (*__first == *__next)
          erase(__next);
        else
          __first = __next;
        __next = __first;
      }
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp,_Alloc>::
    merge(list& __x)
    {


      if (this != &__x)
        {
          iterator __first1 = begin();
          iterator __last1 = end();
          iterator __first2 = __x.begin();
          iterator __last2 = __x.end();
          while (__first1 != __last1 && __first2 != __last2)
            if (*__first2 < *__first1)
              {
                iterator __next = __first2;
                _M_transfer(__first1, __first2, ++__next);
                __first2 = __next;
              }
            else
              ++__first1;
          if (__first2 != __last2)
            _M_transfer(__last1, __first2, __last2);
        }
    }


  inline void
  __List_base_reverse(_List_node_base* __p)
  {
    _List_node_base* __tmp = __p;
    do {
      std::swap(__tmp->_M_next, __tmp->_M_prev);
      __tmp = __tmp->_M_prev;
    } while (__tmp != __p);
  }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp,_Alloc>::
    sort()
    {

      if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node)
      {
        list __carry;
        list __counter[64];
        int __fill = 0;
        while (!empty())
        {
          __carry.splice(__carry.begin(), *this, begin());
          int __i = 0;
          while(__i < __fill && !__counter[__i].empty())
          {
            __counter[__i].merge(__carry);
            __carry.swap(__counter[__i++]);
          }
          __carry.swap(__counter[__i]);
          if (__i == __fill) ++__fill;
        }

        for (int __i = 1; __i < __fill; ++__i)
          __counter[__i].merge(__counter[__i-1]);
        swap(__counter[__fill-1]);
      }
    }

  template<typename _Tp, typename _Alloc>
    template <typename _Predicate>
      void
      list<_Tp,_Alloc>::
      remove_if(_Predicate __pred)
      {
        iterator __first = begin();
        iterator __last = end();
        while (__first != __last)
        {
          iterator __next = __first;
          ++__next;
          if (__pred(*__first)) erase(__first);
          __first = __next;
        }
      }

  template<typename _Tp, typename _Alloc>
    template <typename _BinaryPredicate>
      void
      list<_Tp,_Alloc>::
      unique(_BinaryPredicate __binary_pred)
      {
        iterator __first = begin();
        iterator __last = end();
        if (__first == __last) return;
        iterator __next = __first;
        while (++__next != __last)
        {
          if (__binary_pred(*__first, *__next))
            erase(__next);
          else
            __first = __next;
          __next = __first;
        }
      }

  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp,_Alloc>::
      merge(list& __x, _StrictWeakOrdering __comp)
      {


        if (this != &__x)
          {
            iterator __first1 = begin();
            iterator __last1 = end();
            iterator __first2 = __x.begin();
            iterator __last2 = __x.end();
            while (__first1 != __last1 && __first2 != __last2)
              if (__comp(*__first2, *__first1))
                {
                  iterator __next = __first2;
                  _M_transfer(__first1, __first2, ++__next);
                  __first2 = __next;
                }
              else
                ++__first1;
            if (__first2 != __last2) _M_transfer(__last1, __first2, __last2);
          }
      }

  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
    void
    list<_Tp,_Alloc>::
    sort(_StrictWeakOrdering __comp)
    {

      if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node)
      {
        list __carry;
        list __counter[64];
        int __fill = 0;
        while (!empty())
        {
          __carry.splice(__carry.begin(), *this, begin());
          int __i = 0;
          while(__i < __fill && !__counter[__i].empty())
          {
            __counter[__i].merge(__carry, __comp);
            __carry.swap(__counter[__i++]);
          }
          __carry.swap(__counter[__i]);
          if (__i == __fill) ++__fill;
        }

        for (int __i = 1; __i < __fill; ++__i)
          __counter[__i].merge(__counter[__i-1], __comp);
        swap(__counter[__fill-1]);
      }
    }
}
# 75 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/list" 2 3
# 26 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactoryBase.h" 2


namespace itk
{
# 48 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactoryBase.h"
class OverRideMap;

class ObjectFactoryBase : public Object
{
public:

  typedef ObjectFactoryBase Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  virtual const char *GetNameOfClass() const {return "ObjectFactoryBase";};





  static LightObject::Pointer CreateInstance(const char* itkclassname);





  static std::list<LightObject::Pointer>
  CreateAllInstance(const char* itkclassname);



  static void ReHash();


  static void RegisterFactory(ObjectFactoryBase* );


  static void UnRegisterFactory(ObjectFactoryBase*);


  static void UnRegisterAllFactories();



  static std::list<ObjectFactoryBase*> GetRegisteredFactories();






  virtual const char* GetITKSourceVersion(void) const = 0;


  virtual const char* GetDescription(void) const = 0;


  virtual std::list<std::string> GetClassOverrideNames();


  virtual std::list<std::string> GetClassOverrideWithNames();


  virtual std::list<std::string> GetClassOverrideDescriptions();


  virtual std::list<bool> GetEnableFlags();


  virtual void SetEnableFlag(bool flag,
           const char* className,
           const char* subclassName);


  virtual bool GetEnableFlag(const char* className,
                             const char* subclassName);




  virtual void Disable(const char* className);


  const char* GetLibraryPath();



  struct OverrideInformation
  {
    std::string m_Description;
    std::string m_OverrideWithName;
    bool m_EnabledFlag;
    CreateObjectFunctionBase::Pointer m_CreateObject;
  };

protected:
  virtual void PrintSelf(std::ostream& os, Indent indent) const;


  void RegisterOverride(const char* classOverride,
      const char* overrideClassName,
      const char* description,
      bool enableFlag,
      CreateObjectFunctionBase* createFunction);




  virtual LightObject::Pointer CreateObject(const char* itkclassname );

  ObjectFactoryBase();
  virtual ~ObjectFactoryBase();

private:
  OverRideMap* m_OverrideMap;

  ObjectFactoryBase(const Self&);
  void operator=(const Self&);



  static void Initialize();


  static void RegisterDefaults();


  static void LoadDynamicFactories();


  static void LoadLibrariesInPath( const char*);


  static std::list<ObjectFactoryBase*>* m_RegisteredFactories;



  void* m_LibraryHandle;
  unsigned long m_LibraryDate;
  std::string m_LibraryPath;
  };

}
# 24 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactory.h" 2

namespace itk
{
# 46 "/tmp/installed/include/InsightToolkit/Common/itkObjectFactory.h"
template <class T>
class ObjectFactory : public ObjectFactoryBase
{
public:
  static typename T::Pointer Create()
  {
    LightObject::Pointer ret = ObjectFactory::CreateInstance(typeid(T).name());
    return dynamic_cast<T*>(ret.GetPointer());
  }
};

}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkMutexLock.h" 2
# 38 "/tmp/installed/include/InsightToolkit/Common/itkMutexLock.h"
namespace itk
{






typedef pthread_mutex_t MutexType;
# 70 "/tmp/installed/include/InsightToolkit/Common/itkMutexLock.h"
class SimpleMutexLock
{
public:

  typedef SimpleMutexLock Self;


  SimpleMutexLock();
  virtual ~SimpleMutexLock();


  static SimpleMutexLock *New();
  void Delete() {delete this;}


  virtual const char *GetNameOfClass() {return "itkSimpleMutexLock";};


  void Lock( void );


  void Unlock( void );


  MutexType& GetMutexLock()
  {
    return m_MutexLock;
  }
  const MutexType GetMutexLock() const
  {
    return m_MutexLock;
  }

protected:
  MutexType m_MutexLock;
};
# 116 "/tmp/installed/include/InsightToolkit/Common/itkMutexLock.h"
class MutexLock : public Object
{
public:

  typedef MutexLock Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "MutexLock";};


  void Lock( void );


  void Unlock( void );

protected:
  MutexLock() {}
  ~MutexLock() {}

  SimpleMutexLock m_SimpleMutexLock;
  void PrintSelf(std::ostream& os, Indent indent) const;

private:
  MutexLock(const Self&);
  void operator=(const Self&);
};


inline void MutexLock::Lock( void )
{
  m_SimpleMutexLock.Lock();
}

inline void MutexLock::Unlock( void )
{
  m_SimpleMutexLock.Unlock();
}


}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h" 2
# 53 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h"
namespace itk
{
# 77 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h"
#define ITK_MAX_THREADS 128
# 104 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h"
typedef void *(*ThreadFunctionType)(void *);
typedef pthread_t ThreadProcessIDType;
#define ITK_THREAD_RETURN_VALUE NULL
#define ITK_THREAD_RETURN_TYPE void *
# 124 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h"
class MultiThreader : public Object
{
public:

  typedef MultiThreader Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "MultiThreader";};




  virtual void SetNumberOfThreads (int _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h" ", line " << 142 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " << "NumberOfThreads" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_NumberOfThreads != (_arg<1?1:(_arg>128?128:_arg))) { this->m_NumberOfThreads = (_arg<1?1:(_arg>128?128:_arg)); this->Modified(); } };
  virtual int GetNumberOfThreads () { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h" ", line " << 143 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "NumberOfThreads" " of " << this->m_NumberOfThreads << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_NumberOfThreads; };




  static void SetGlobalMaximumNumberOfThreads(int val);
  static int GetGlobalMaximumNumberOfThreads();




  static void SetGlobalDefaultNumberOfThreads(int val);
  static int GetGlobalDefaultNumberOfThreads();



  void SingleMethodExecute();




  void MultipleMethodExecute();






  void SetSingleMethod(ThreadFunctionType, void *data );



  void SetMultipleMethod( int index, ThreadFunctionType, void *data );




  int SpawnThread( ThreadFunctionType, void *data );


  void TerminateThread( int thread_id );
# 208 "/tmp/installed/include/InsightToolkit/Common/itkMultiThreader.h"
  struct ThreadInfoStruct
  {



    int ThreadID;
    int NumberOfThreads;
    int *ActiveFlag;
    MutexLock::Pointer ActiveFlagLock;
    void *UserData;



  };

protected:
  MultiThreader();
  ~MultiThreader();
  void PrintSelf(std::ostream& os, Indent indent) const;

private:







  MultiThreader(const Self&);
  void operator=(const Self&);


  int m_NumberOfThreads;




  ThreadInfoStruct m_ThreadInfoArray[128];


  ThreadFunctionType m_SingleMethod;
  ThreadFunctionType m_MultipleMethod[128];



  int m_SpawnedThreadActiveFlag [128];
  MutexLock::Pointer m_SpawnedThreadActiveFlagLock[128];
  ThreadProcessIDType m_SpawnedThreadProcessID [128];
  ThreadInfoStruct m_SpawnedThreadInfoArray [128];


  void *m_SingleData;
  void *m_MultipleData[128];


  static int m_GlobalMaximumNumberOfThreads;
  static int m_GlobalDefaultNumberOfThreads;




  friend class ProcessObject;
};

}
# 26 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" 2



namespace itk
{
# 87 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
class ProcessObject : public Object
{
public:

  typedef ProcessObject Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  virtual const char *GetNameOfClass() const {return "ProcessObject";};


  typedef DataObject::Pointer DataObjectPointer;


  typedef std::vector<DataObjectPointer> DataObjectPointerArray;




  DataObjectPointerArray& GetInputs()
    {return m_Inputs;}





  std::vector<DataObjectPointer>::size_type GetNumberOfInputs() const
    {return m_Inputs.size();}
# 125 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual std::vector<DataObjectPointer>::size_type GetNumberOfValidRequiredInputs() const;




  DataObjectPointerArray& GetOutputs()
    { return m_Outputs; }
  std::vector<DataObjectPointer>::size_type GetNumberOfOutputs() const
    {return m_Outputs.size();}



  virtual void SetAbortGenerateData (const bool _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 137 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "AbortGenerateData" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_AbortGenerateData != _arg) { this->m_AbortGenerateData = _arg; this->Modified(); } };



  virtual const bool & GetAbortGenerateData () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 141 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "AbortGenerateData" " of " << this->m_AbortGenerateData << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_AbortGenerateData; };


  virtual void AbortGenerateDataOn () { this->SetAbortGenerateData(true);} virtual void AbortGenerateDataOff () { this->SetAbortGenerateData(false);};





  virtual void SetProgress (float _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 150 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " << "Progress" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_Progress != (_arg<0.0?0.0:(_arg>1.0?1.0:_arg))) { this->m_Progress = (_arg<0.0?0.0:(_arg>1.0?1.0:_arg)); this->Modified(); } };




  virtual const float & GetProgress () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 155 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "Progress" " of " << this->m_Progress << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_Progress; };






  void UpdateProgress(float amount);
# 182 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void Update();







  virtual void UpdateLargestPossibleRegion();
# 204 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void UpdateOutputInformation();



  virtual void PropagateRequestedRegion(DataObject *output);


  virtual void UpdateOutputData(DataObject *output);
# 221 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void EnlargeOutputRequestedRegion(DataObject *){};





  virtual void ResetPipeline();
# 243 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual DataObjectPointer MakeOutput(unsigned int idx);






  virtual void SetReleaseDataFlag(bool flag);
  virtual bool GetReleaseDataFlag() const;
  void ReleaseDataFlagOn() {this->SetReleaseDataFlag(true);}
  void ReleaseDataFlagOff() {this->SetReleaseDataFlag(false);}
# 267 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void SetReleaseDataBeforeUpdateFlag (const bool _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 267 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "ReleaseDataBeforeUpdateFlag" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_ReleaseDataBeforeUpdateFlag != _arg) { this->m_ReleaseDataBeforeUpdateFlag = _arg; this->Modified(); } };
  virtual bool GetReleaseDataBeforeUpdateFlag () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 268 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "ReleaseDataBeforeUpdateFlag" " of " << this->m_ReleaseDataBeforeUpdateFlag << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_ReleaseDataBeforeUpdateFlag; };
  virtual void ReleaseDataBeforeUpdateFlagOn () { this->SetReleaseDataBeforeUpdateFlag(true);} virtual void ReleaseDataBeforeUpdateFlagOff () { this->SetReleaseDataBeforeUpdateFlag(false);};



  virtual void SetNumberOfThreads (int _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 273 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " << "NumberOfThreads" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_NumberOfThreads != (_arg<1?1:(_arg>128?128:_arg))) { this->m_NumberOfThreads = (_arg<1?1:(_arg>128?128:_arg)); this->Modified(); } };
  virtual const int & GetNumberOfThreads () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 274 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "NumberOfThreads" " of " << this->m_NumberOfThreads << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_NumberOfThreads; };


  MultiThreader * GetMultiThreader()
    {return m_Threader;}







  virtual void PrepareOutputs();

protected:
  ProcessObject();
  ~ProcessObject();
  void PrintSelf(std::ostream& os, Indent indent) const;



  virtual void SetNthInput(unsigned int num, DataObject *input);
  virtual void AddInput(DataObject *input);
  virtual void RemoveInput(DataObject *input);
  virtual void SetNumberOfRequiredInputs (const unsigned int _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 298 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "NumberOfRequiredInputs" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_NumberOfRequiredInputs != _arg) { this->m_NumberOfRequiredInputs = _arg; this->Modified(); } };
  virtual const unsigned int & GetNumberOfRequiredInputs () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 299 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "NumberOfRequiredInputs" " of " << this->m_NumberOfRequiredInputs << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_NumberOfRequiredInputs; };


  void SetNumberOfInputs(unsigned int num);


  DataObject * GetInput(unsigned int idx);
  const DataObject * GetInput(unsigned int idx) const;



  virtual void SetNthOutput(unsigned int num, DataObject *output);
  virtual void AddOutput(DataObject *output);
  virtual void RemoveOutput(DataObject *output);
  virtual void SetNumberOfRequiredOutputs (const unsigned int _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 313 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "NumberOfRequiredOutputs" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_NumberOfRequiredOutputs != _arg) { this->m_NumberOfRequiredOutputs = _arg; this->Modified(); } };
  virtual const unsigned int & GetNumberOfRequiredOutputs () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h" ", line " << 314 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "NumberOfRequiredOutputs" " of " << this->m_NumberOfRequiredOutputs << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_NumberOfRequiredOutputs; };


  void SetNumberOfOutputs(unsigned int num);


  DataObject * GetOutput(unsigned int idx);
  const DataObject * GetOutput(unsigned int idx) const;
# 336 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void GenerateInputRequestedRegion();
# 349 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void GenerateOutputRequestedRegion(DataObject *output);
# 361 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void GenerateOutputInformation();


  virtual void GenerateData() {}




  virtual void PropagateResetPipeline();
# 382 "/tmp/installed/include/InsightToolkit/Common/itkProcessObject.h"
  virtual void ReleaseInputs();






  bool m_Updating;


  TimeStamp m_OutputInformationMTime;

private:
  ProcessObject(const Self&);
  void operator=(const Self&);


  std::vector<DataObjectPointer> m_Inputs;
  unsigned int m_NumberOfRequiredInputs;


  std::vector<DataObjectPointer> m_Outputs;
  unsigned int m_NumberOfRequiredOutputs;


  bool m_AbortGenerateData;
  float m_Progress;



  MultiThreader::Pointer m_Threader;
  int m_NumberOfThreads;


  bool m_ReleaseDataBeforeUpdateFlag;


  friend class DataObject;
};

}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkIndex.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkIndex.h"
#define __itkIndex_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkOffset.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkOffset.h"
#define __itkOffset_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkSize.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkSize.h"
#define __itkSize_h 



namespace itk
{
# 45 "/tmp/installed/include/InsightToolkit/Common/itkSize.h"
template<unsigned int VDimension=2>
class Size {
public:

  typedef Size Self;


  typedef Size<VDimension> SizeType;
  typedef unsigned long SizeValueType;


  static unsigned int GetSizeDimension(void) { return VDimension; }


  const Self
  operator+(const Self &vec)
    {
    Self result;
    for (unsigned int i=0; i < VDimension; i++)
      { result[i] = m_Size[i] + vec.m_Size[i]; }
    return result;
    }


  const Self &
  operator+=(const Self &vec)
    {
    for (unsigned int i=0; i < VDimension; i++)
      { m_Size[i] += vec.m_Size[i]; }
    return *this;
    }


  const Self
  operator-(const Self &vec)
    {
    Self result;
    for (unsigned int i=0; i < VDimension; i++)
      { result[i] = m_Size[i] - vec.m_Size[i]; }
    return result;
    }


  const Self &
  operator-=(const Self &vec)
    {
    for (unsigned int i=0; i < VDimension; i++)
      { m_Size[i] -= vec.m_Size[i]; }
    return *this;
    }


  const Self
  operator*(const Self &vec)
    {
    Self result;
    for (unsigned int i=0; i < VDimension; i++)
      { result[i] = m_Size[i] * vec.m_Size[i]; }
    return result;
    }


  const Self &
  operator*=(const Self &vec)
    {
    for (unsigned int i=0; i < VDimension; i++)
      { m_Size[i] *= vec.m_Size[i]; }
    return *this;
    }


  bool
  operator==(const Self &vec) const
    {
    bool same=1;
    for (unsigned int i=0; i < VDimension && same; i++)
      { same = (m_Size[i] == vec.m_Size[i]); }
    return same;
    }


  bool
  operator!=(const Self &vec) const
    {
    bool same=1;
    for (unsigned int i=0; i < VDimension && same; i++)
      { same = (m_Size[i] == vec.m_Size[i]); }
    return !same;
    }



  SizeValueType & operator[](unsigned int dim)
    { return m_Size[dim]; }




  SizeValueType operator[](unsigned int dim) const
    { return m_Size[dim]; }



  const SizeValueType *GetSize() const { return m_Size; };




  void SetSize(const SizeValueType val[VDimension])
    { memcpy(m_Size, val, sizeof(SizeValueType)*VDimension); }







  void SetElement(unsigned long element, SizeValueType val )
    { m_Size[ element ] = val; }







  SizeValueType GetElement( unsigned long element ) const
    { return m_Size[ element ]; }



  void Fill(SizeValueType value)
    { for(unsigned int i=0;i < VDimension; ++i) m_Size[i] = value; }
# 189 "/tmp/installed/include/InsightToolkit/Common/itkSize.h"
  SizeValueType m_Size[VDimension];

};


template<unsigned int VDimension>
std::ostream & operator<<(std::ostream &os, const Size<VDimension> &size)
{
  os << "[";
  for (unsigned int i=0; i+1 < VDimension; ++i)
    {
    os << size[i] << ", ";
    }
  if (VDimension >= 1)
    {
    os << size[VDimension-1];
    }
  os << "]";
  return os;
}
# 222 "/tmp/installed/include/InsightToolkit/Common/itkSize.h"
}
# 22 "/tmp/installed/include/InsightToolkit/Common/itkOffset.h" 2



# 1 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 1
# 26 "/tmp/installed/include/InsightToolkit/Common/itkOffset.h" 2

namespace itk
{
# 47 "/tmp/installed/include/InsightToolkit/Common/itkOffset.h"
template<unsigned int VOffsetDimension=2>
class Offset {
public:

  typedef Offset Self;


  static unsigned int GetOffsetDimension() { return VOffsetDimension; }


  typedef Offset<VOffsetDimension> OffsetType;
  typedef long OffsetValueType;


  const Self
  operator+(const Self &offset) const
    {
    Self result;
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { result[i] = m_Offset[i] + offset[i]; }
    return result;
    }


  const Self
  operator+(const Size<VOffsetDimension> &size) const
    {
    Self result;
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { result[i] = m_Offset[i] + size[i]; }
    return result;
    }


  const Self &
  operator+=(const Size<VOffsetDimension> &size)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] += size[i]; }
    return *this;
    }


  const Self &
  operator-=(const Size<VOffsetDimension> &size)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] -= size[i]; }
    return *this;
    }


  const Self
  operator-(const Self &vec)
    {
    Self result;
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { result[i] = m_Offset[i] - vec.m_Offset[i]; }
    return result;
    }


  const Self &
  operator+=(const Self &vec)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] += vec.m_Offset[i]; }
    return *this;
    }


  const Self &
  operator-=(const Self &vec)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] -= vec.m_Offset[i]; }
    return *this;
    }


  bool
  operator==(const Self &vec) const
    {
    bool same=1;
    for (unsigned int i=0; i < VOffsetDimension && same; i++)
      { same = (m_Offset[i] == vec.m_Offset[i]); }
    return same;
    }


  bool
  operator!=(const Self &vec) const
    {
    bool same=1;
    for (unsigned int i=0; i < VOffsetDimension && same; i++)
      { same = (m_Offset[i] == vec.m_Offset[i]); }
    return !same;
    }



  OffsetValueType & operator[](unsigned int dim)
    { return m_Offset[dim]; }




  OffsetValueType operator[](unsigned int dim) const
    { return m_Offset[dim]; }



  const OffsetValueType *GetOffset() const { return m_Offset; };





  void SetOffset(const OffsetValueType val[VOffsetDimension])
    { memcpy(m_Offset, val, sizeof(OffsetValueType)*VOffsetDimension); }




  static Self GetBasisOffset(unsigned int dim);



  void Fill(OffsetValueType value)
    { for(unsigned int i=0;i < VOffsetDimension; ++i) m_Offset[i] = value; }






  OffsetValueType m_Offset[VOffsetDimension];

};


template<unsigned int VOffsetDimension>
Offset<VOffsetDimension>
Offset<VOffsetDimension>
::GetBasisOffset(unsigned int dim)
{
  Self ind;

  memset(ind.m_Offset, 0, sizeof(OffsetValueType)*VOffsetDimension);
  ind.m_Offset[dim] = 1;
  return ind;
}

template<unsigned int VOffsetDimension>
std::ostream & operator<<(std::ostream &os, const Offset<VOffsetDimension> &ind)
{
  os << "[";
  unsigned int dimlim = VOffsetDimension - 1;
  for (unsigned int i=0; i < dimlim; ++i)
    {
    os << ind[i] << ", ";
    }
  if (VOffsetDimension >= 1)
    {
    os << ind[VOffsetDimension-1];
    }
  os << "]";
  return os;
}

}
# 22 "/tmp/installed/include/InsightToolkit/Common/itkIndex.h" 2




# 1 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 1
# 27 "/tmp/installed/include/InsightToolkit/Common/itkIndex.h" 2

namespace itk
{
# 61 "/tmp/installed/include/InsightToolkit/Common/itkIndex.h"
template<unsigned int VIndexDimension=2>
class Index {
public:

  typedef Index Self;


  typedef Index<VIndexDimension> IndexType;
  typedef long IndexValueType;


  static unsigned int GetIndexDimension() { return VIndexDimension; }


  typedef Size<VIndexDimension> SizeType;


  typedef Offset<VIndexDimension> OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;


  const Self
  operator+(const SizeType &size) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] + static_cast<IndexValueType>(size[i]); }
    return result;
    }


  const Self &
  operator+=(const SizeType &size)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] += static_cast<IndexValueType>(size[i]); }
    return *this;
    }


  const Self
  operator-(const SizeType &size) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] - static_cast<IndexValueType>(size[i]); }
    return result;
    }


  const Self &
  operator-=(const SizeType &size)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] -= static_cast<IndexValueType>(size[i]); }
    return *this;
    }


  const Self
  operator+(const OffsetType &offset) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] + offset[i]; }
    return result;
    }


  const Self &
  operator+=(const OffsetType &offset)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] += offset[i]; }
    return *this;
    }


  const Self &
  operator-=(const OffsetType &offset)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] -= offset[i]; }
    return *this;
    }


  const Self
  operator-(const OffsetType &off) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] - off.m_Offset[i]; }
    return result;
    }


  const OffsetType
  operator-(const Self &vec) const
    {
    OffsetType result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] - vec.m_Index[i]; }
    return result;
    }



  const Self
  operator*(const SizeType &vec) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] * static_cast<IndexValueType>(vec.m_Size[i]); }
    return result;
    }


  bool
  operator==(const Self &vec) const
    {
    bool same=true;
    for (unsigned int i=0; i < VIndexDimension && same; i++)
      { same = (m_Index[i] == vec.m_Index[i]); }
    return same;
    }


  bool
  operator!=(const Self &vec) const
    {
    bool same=true;
    for (unsigned int i=0; i < VIndexDimension && same; i++)
      { same = (m_Index[i] == vec.m_Index[i]); }
    return !same;
    }



  IndexValueType & operator[](unsigned int dim)
    { return m_Index[dim]; }




  IndexValueType operator[](unsigned int dim) const
    { return m_Index[dim]; }



  const IndexValueType *GetIndex() const { return m_Index; };





  void SetIndex(const IndexValueType val[VIndexDimension])
    { memcpy(m_Index, val, sizeof(IndexValueType)*VIndexDimension); }







  void SetElement(unsigned long element, IndexValueType val )
    { m_Index[ element ] = val; }







  IndexValueType GetElement( unsigned long element )
    { return m_Index[ element ]; }




  static Self GetBasisIndex(unsigned int dim);



  void Fill(IndexValueType value)
    { for(unsigned int i=0;i < VIndexDimension; ++i) m_Index[i] = value; }






  IndexValueType m_Index[VIndexDimension];

};


template<unsigned int VIndexDimension>
Index<VIndexDimension>
Index<VIndexDimension>
::GetBasisIndex(unsigned int dim)
{
  Self ind;

  memset(ind.m_Index, 0, sizeof(IndexValueType)*VIndexDimension);
  ind.m_Index[dim] = 1;
  return ind;
}

template<unsigned int VIndexDimension>
std::ostream & operator<<(std::ostream &os, const Index<VIndexDimension> &ind)
{
  os << "[";
  for (unsigned int i=0; i+1 < VIndexDimension; ++i)
    {
    os << ind[i] << ", ";
    }
  if (VIndexDimension >= 1)
    {
    os << ind[VIndexDimension-1];
    }
  os << "]";
  return os;
}
# 300 "/tmp/installed/include/InsightToolkit/Common/itkIndex.h"
}
# 26 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 2


# 1 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.h"
#define __itkFixedArray_h 
# 27 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.h"
namespace itk
{







template <typename TVector>
struct GetVectorDimension
{
  static const unsigned int VectorDimension = TVector::Dimension;
};
# 63 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.h"
template <typename TValueType, unsigned int VLength=3>
class FixedArray
{
public:

  static const unsigned int Length = VLength;


  static const unsigned int Dimension = VLength;


  typedef TValueType ValueType;


  typedef ValueType CArray[VLength];


  typedef ValueType* Iterator;


  typedef const ValueType* ConstIterator;


  class ReverseIterator
  {
  public:
    explicit ReverseIterator(Iterator i): m_Iterator(i) {}
    Iterator operator++() { return --m_Iterator; }
    Iterator operator++(int) { return m_Iterator--; }
    Iterator operator--() { return ++m_Iterator; }
    Iterator operator--(int) { return m_Iterator++; }
    Iterator operator->() const { return (m_Iterator-1); }
    ValueType& operator*() const { return *(m_Iterator-1); }
  private:
    Iterator m_Iterator;
  };


  class ConstReverseIterator
  {
  public:
    explicit ConstReverseIterator(ConstIterator i): m_Iterator(i) {}
    ConstIterator operator++() { return --m_Iterator; }
    ConstIterator operator++(int) { return m_Iterator--; }
    ConstIterator operator--() { return ++m_Iterator; }
    ConstIterator operator--(int) { return m_Iterator++; }
    ConstIterator operator->() const { return (m_Iterator-1); }
    const ValueType& operator*() const { return *(m_Iterator-1); }
  private:
    ConstIterator m_Iterator;
  };


  typedef ValueType* pointer;


  typedef const ValueType* const_pointer;


  typedef ValueType& reference;


  typedef const ValueType& const_reference;

  typedef unsigned int SizeType;

public:

  FixedArray();
  FixedArray(const FixedArray& r);
  FixedArray(const ValueType r[VLength]);



  ~FixedArray();


  FixedArray& operator= (const FixedArray& r);
  FixedArray& operator= (const ValueType r[VLength]);




  bool operator==(const FixedArray& r ) const;
  bool operator!=(const FixedArray& r ) const
    { return !operator==(r); }




        reference operator[](short index) { return m_InternalArray[index]; }
  const_reference operator[](short index) const { return m_InternalArray[index]; }
        reference operator[](unsigned short index) { return m_InternalArray[index]; }
  const_reference operator[](unsigned short index) const { return m_InternalArray[index]; }
        reference operator[](int index) { return m_InternalArray[index]; }
  const_reference operator[](int index) const { return m_InternalArray[index]; }
        reference operator[](unsigned int index) { return m_InternalArray[index]; }
  const_reference operator[](unsigned int index) const { return m_InternalArray[index]; }
        reference operator[](long index) { return m_InternalArray[index]; }
  const_reference operator[](long index) const { return m_InternalArray[index]; }
        reference operator[](unsigned long index) { return m_InternalArray[index]; }
  const_reference operator[](unsigned long index) const { return m_InternalArray[index]; }


  void SetElement( unsigned short index, const_reference value )
                                  { m_InternalArray[ index ] = value; }
  const_reference GetElement( unsigned short index ) const { return m_InternalArray[index]; }


  ValueType* GetDataPointer() { return m_InternalArray; }
  const ValueType* GetDataPointer() const { return m_InternalArray; }


  Iterator Begin();
  ConstIterator Begin() const;
  Iterator End();
  ConstIterator End() const;
  ReverseIterator rBegin();
  ConstReverseIterator rBegin() const;
  ReverseIterator rEnd();
  ConstReverseIterator rEnd() const;
  SizeType Size() const;
  void Fill(const ValueType&);

private:

  CArray m_InternalArray;

public:

  static FixedArray Filled(const ValueType&);
};

template <typename TValueType, unsigned int VLength>
std::ostream & operator<<(std::ostream &os, const FixedArray<TValueType,VLength> &arr)
{
  os << "[";
  if ( VLength == 1 )
    {
    os << arr[0] ;
    }
  else
    {
    for (int i=0; i < static_cast<int>(VLength) - 1; ++i)
      {
      os << arr[i] << ", ";
      }
    os << arr[VLength-1];
    }
  os << "]";
  return os;
}

}






# 1 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.txx"
#define _itkFixedArray_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.txx" 2

namespace itk
{





template <typename TValueType, unsigned int VLength>
FixedArray<TValueType, VLength>
::FixedArray()
{
}






template <typename TValueType, unsigned int VLength>
FixedArray<TValueType, VLength>
::FixedArray(const FixedArray& r)
{
  ConstIterator input = r.Begin();
  for(Iterator i = this->Begin() ; i != this->End() ;) *i++ = *input++;
}






template <typename TValueType, unsigned int VLength>
FixedArray<TValueType, VLength>
::FixedArray(const ValueType r[VLength])
{
  ConstIterator input = r;
  for(Iterator i = this->Begin() ; i != this->End() ;) *i++ = *input++;
}





template <typename TValueType, unsigned int VLength>
FixedArray<TValueType, VLength>
::~FixedArray()
{
}







template <typename TValueType, unsigned int VLength>
FixedArray<TValueType, VLength>&
FixedArray<TValueType, VLength>
::operator= (const FixedArray& r)
{
  if(r.Begin() == m_InternalArray) return *this;
  ConstIterator input = r.Begin();
  for(Iterator i = this->Begin() ; i != this->End() ;) *i++ = *input++;
  return *this;
}







template <typename TValueType, unsigned int VLength>
FixedArray<TValueType, VLength>&
FixedArray<TValueType, VLength>
::operator= (const ValueType r[VLength])
{
  if(r == m_InternalArray) return *this;
  ConstIterator input = r;
  for(Iterator i = this->Begin() ; i != this->End() ;) *i++ = *input++;
  return *this;
}





template <typename TValueType, unsigned int VLength>
bool
FixedArray<TValueType, VLength>
::operator== (const FixedArray& r) const
{
  ConstIterator i = this->Begin();
  ConstIterator j = r.Begin();

  for( ; i != this->End(); ++i, ++j )
    {
    if ( *i != *j ) {return false;}
    }

  return true;
}




template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::Iterator
FixedArray<TValueType, VLength>
::Begin()
{
  return Iterator(m_InternalArray);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::ConstIterator
FixedArray<TValueType, VLength>
::Begin() const
{
  return ConstIterator(m_InternalArray);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::Iterator
FixedArray<TValueType, VLength>
::End()
{
  return Iterator(m_InternalArray+VLength);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::ConstIterator
FixedArray<TValueType, VLength>
::End() const
{
  return ConstIterator(m_InternalArray+VLength);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::ReverseIterator
FixedArray<TValueType, VLength>
::rBegin()
{
  return ReverseIterator(m_InternalArray+VLength);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::ConstReverseIterator
FixedArray<TValueType, VLength>
::rBegin() const
{
  return ConstReverseIterator(m_InternalArray+VLength);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::ReverseIterator
FixedArray<TValueType, VLength>
::rEnd()
{
  return ReverseIterator(m_InternalArray);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::ConstReverseIterator
FixedArray<TValueType, VLength>
::rEnd() const
{
  return ConstReverseIterator(m_InternalArray);
}





template <typename TValueType, unsigned int VLength>
typename FixedArray<TValueType, VLength>::SizeType
FixedArray<TValueType, VLength>
::Size() const
{
  return VLength;
}





template <typename TValueType, unsigned int VLength>
void
FixedArray<TValueType, VLength>
::Fill(const ValueType& value)
{
  for(Iterator i = this->Begin() ; i != this->End() ;) *i++ = value;
}





template <typename TValueType, unsigned int VLength>
FixedArray<TValueType, VLength>
FixedArray<TValueType, VLength>
::Filled(const ValueType& value)
{
  FixedArray<ValueType, VLength> array;
  array.Fill(value);
  return array;
}


}
# 224 "/tmp/installed/include/InsightToolkit/Common/itkFixedArray.h" 2
# 29 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
#define __itkPoint_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkVector.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkVector.h"
#define __itkVector_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkNumericTraits.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkNumericTraits.h"
#define __itkNumericTraits_h 





# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_limits.h" 1


#define vcl_limits_h_ 

# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h" 1


#define vcl_compiler_h_ 
# 49 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h"
#define VCL_GCC 
# 68 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h"
#define VCL_GCC_30 

#define VCL_GCC_31 


#define VCL_GCC_32 
# 141 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_manual.h" 1

#define vcl_config_manual_h_ 
# 11 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_manual.h"
#define VCL_USE_NATIVE_STL 1




#define VCL_USE_NATIVE_COMPLEX 1







#define VCL_USE_IMPLICIT_TEMPLATES 1
# 142 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h" 1

#define vcl_config_compiler_h_ 
# 12 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_HAS_BOOL 1






#define VCL_HAS_DYNAMIC_CAST 1






#define VCL_HAS_RTTI 1






#define VCL_HAS_TYPENAME 1






#define VCL_HAS_EXPORT 1






#define VCL_HAS_MUTABLE 1






#define VCL_HAS_EXPLICIT 1






#define VCL_FOR_SCOPE_HACK 1
# 72 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_DEFAULT_VALUE(x) 
# 114 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_CAN_STATIC_CONST_INIT_INT 1


#define VCL_STATIC_CONST_INIT_INT_DECL(x) = x
#define VCL_STATIC_CONST_INIT_INT_DEFN(x) 
#define VCL_STATIC_CONST_INIT_INT_NO_DEFN 0
# 138 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_CAN_STATIC_CONST_INIT_FLOAT 1


#define VCL_STATIC_CONST_INIT_FLOAT_DECL(x) = x
#define VCL_STATIC_CONST_INIT_FLOAT_DEFN(x) 
#define VCL_STATIC_CONST_INIT_FLOAT_NO_DEFN 0
# 162 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_HAS_MEMBER_TEMPLATES 1
# 173 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_CAN_DO_PARTIAL_SPECIALIZATION 1
# 192 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_DEFINE_SPECIALIZATION template <>
# 205 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_CANNOT_SPECIALIZE_CV 0
# 240 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_TEMPLATE_MATCHES_TOO_OFTEN 0
# 266 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_HAS_SLICED_DESTRUCTOR_BUG 0
# 276 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_NULL_TMPL_ARGS <>
# 286 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_ALLOWS_INLINE_INSTANTIATION 1






#define VCL_NEEDS_INLINE_INSTANTIATION 0
# 325 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_DO_NOT_INSTANTIATE(text,ret) VCL_DEFINE_SPECIALIZATION text { return ret; }
# 343 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_UNINSTANTIATE_SPECIALIZATION(symbol) 
# 358 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_UNINSTANTIATE_UNSEEN_SPECIALIZATION(symbol) 
# 404 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_CAN_DO_STATIC_TEMPLATE_MEMBER 1

#define VCL_INSTANTIATE_STATIC_TEMPLATE_MEMBER(symbol) 
#define VCL_UNINSTANTIATE_STATIC_TEMPLATE_MEMBER(symbol) 
# 424 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_CAN_DO_NON_TYPE_FUNCTION_TEMPLATE_PARAMETER 1
# 442 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_NEED_FRIEND_FOR_TEMPLATE_OVERLOAD 0
# 459 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_OVERLOAD_CAST(T,x) (x)
# 470 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_NO_STATIC_DATA_MEMBERS 0
# 479 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_HAS_TEMPLATE_SYMBOLS 1
# 507 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_DEFAULT_TMPL_ARG(arg) 


#define VCL_CAN_DO_COMPLETE_DEFAULT_TYPE_PARAMETER 1
#define VCL_CAN_DO_TEMPLATE_DEFAULT_TYPE_PARAMETER 1
# 566 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_SUNPRO_CLASS_SCOPE_HACK(A) 
# 575 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_compiler.h"
#define VCL_HAS_EXCEPTIONS 1




#define VCL_HAS_NAMESPACES 1




#define VCL_ALLOWS_NAMESPACE_STD 1




#define VCL_NEEDS_NAMESPACE_STD 1






#define VCL_NUMERIC_LIMITS_HAS_INFINITY 1





#define VCL_PROCESSOR_HAS_INFINITY 1






#define VCL_CHAR_IS_SIGNED 1
# 143 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_config_headers.h" 1

#define vcl_config_headers_h_ 







#define VCL_CXX_HAS_HEADER_CASSERT 1
#define VCL_CXX_HAS_HEADER_CISO646 1
#define VCL_CXX_HAS_HEADER_CSETJMP 1
#define VCL_CXX_HAS_HEADER_CSTDIO 1
#define VCL_CXX_HAS_HEADER_CTIME 1
#define VCL_CXX_HAS_HEADER_CCTYPE 1
#define VCL_CXX_HAS_HEADER_CLIMITS 1
#define VCL_CXX_HAS_HEADER_CSIGNAL 1
#define VCL_CXX_HAS_HEADER_CSTDLIB 1
#define VCL_CXX_HAS_HEADER_CWCHAR 1
#define VCL_CXX_HAS_HEADER_CERRNO 1
#define VCL_CXX_HAS_HEADER_CLOCALE 1
#define VCL_CXX_HAS_HEADER_CSTDARG 1
#define VCL_CXX_HAS_HEADER_CSTRING 1
#define VCL_CXX_HAS_HEADER_CWCTYPE 1
#define VCL_CXX_HAS_HEADER_CFLOAT 1
#define VCL_CXX_HAS_HEADER_CMATH 1
#define VCL_CXX_HAS_HEADER_CSTDDEF 1
#define VCL_CXX_HAS_HEADER_ALGORITHM 1
#define VCL_CXX_HAS_HEADER_IOMANIP 1
#define VCL_CXX_HAS_HEADER_LIST 1
#define VCL_CXX_HAS_HEADER_OSTREAM 1
#define VCL_CXX_HAS_HEADER_STREAMBUF 1
#define VCL_CXX_HAS_HEADER_BITSET 1
#define VCL_CXX_HAS_HEADER_IOS 1
#define VCL_CXX_HAS_HEADER_LOCALE 1
#define VCL_CXX_HAS_HEADER_QUEUE 1
#define VCL_CXX_HAS_HEADER_STRING 1
#define VCL_CXX_HAS_HEADER_COMPLEX 1
#define VCL_CXX_HAS_HEADER_IOSFWD 1
#define VCL_CXX_HAS_HEADER_MAP 1
#define VCL_CXX_HAS_HEADER_SET 1
#define VCL_CXX_HAS_HEADER_TYPEINFO 1
#define VCL_CXX_HAS_HEADER_DEQUE 1
#define VCL_CXX_HAS_HEADER_IOSTREAM 1
#define VCL_CXX_HAS_HEADER_MEMORY 1
#define VCL_CXX_HAS_HEADER_SSTREAM 1
#define VCL_CXX_HAS_HEADER_UTILITY 1
#define VCL_CXX_HAS_HEADER_EXCEPTION 1
#define VCL_CXX_HAS_HEADER_ISTREAM 1
#define VCL_CXX_HAS_HEADER_NEW 1
#define VCL_CXX_HAS_HEADER_STACK 1
#define VCL_CXX_HAS_HEADER_VALARRAY 1
#define VCL_CXX_HAS_HEADER_FSTREAM 1
#define VCL_CXX_HAS_HEADER_ITERATOR 1
#define VCL_CXX_HAS_HEADER_NUMERIC 1
#define VCL_CXX_HAS_HEADER_STDEXCEPT 1
#define VCL_CXX_HAS_HEADER_VECTOR 1
#define VCL_CXX_HAS_HEADER_FUNCTIONAL 1
#define VCL_CXX_HAS_HEADER_LIMITS 1
#define VCL_CXX_HAS_HEADER_STRSTREAM 1

#define VCL_CXX_HAS_HEADER_ISO646_H 1
# 144 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h" 2




#define GNU_LIBSTDCXX_V3 1
# 158 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h"
#define VCL_DFL_TYPE_PARAM_STLDECL(A,a) class A = a





#define VCL_DFL_TMPL_PARAM_STLDECL(A,a) class A = a




#define VCL_DFL_TMPL_ARG(classname) , classname


#define VCL_SUNPRO_ALLOCATOR_HACK(T) T VCL_SUNPRO_CLASS_SCOPE_HACK(std::allocator<T >)
# 182 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h"
#define export 





#define VCL_INSTANTIATE_INLINE(symbol) 
# 197 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_compiler.h"
#define IUEi_STL_INLINE inline






#define for if (false) { } else for
typedef int saw_VCL_FOR_SCOPE_HACK;



#define VCL_INSTANTIATE_NONINLINE(fn_decl) template fn_decl







#define VCL_COMMA ,






#define VCL_VOID_RETURN 
# 6 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_limits.h" 2






# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_limits.h" 1

#define vcl_iso_limits_h_ 
# 11 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_limits.h"
#define vcl_generic_limits_STD std


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_limits.h" 1

#define vcl_generic_limits_h_ 





#define vcl_numeric_limits vcl_generic_limits_STD :: numeric_limits



#define vcl_float_round_style vcl_generic_limits_STD :: float_round_style



#define vcl_float_denorm_style vcl_generic_limits_STD :: float_denorm_style



#define vcl_round_toward_zero vcl_generic_limits_STD :: round_toward_zero



#define vcl_round_toward_neg_infinity vcl_generic_limits_STD :: round_toward_neg_infinity
# 15 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_limits.h" 2
# 13 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_limits.h" 2
# 25 "/tmp/installed/include/InsightToolkit/Common/itkNumericTraits.h" 2

namespace itk
{
# 39 "/tmp/installed/include/InsightToolkit/Common/itkNumericTraits.h"
template <class T>
class NumericTraits : public std :: numeric_limits<T> {
public:

  typedef T ValueType;


  typedef T PrintType;


  typedef T AbsType;


  typedef double AccumulateType;


  static const T Zero;


  static const T One;


  static T NonpositiveMin() { return NumericTraits<T>::min(); }


  static bool IsPositive(T val) { return val > Zero; }


  static bool IsNonpositive(T val) { return val <= Zero; }


  static bool IsNegative(T val) { return val < Zero; }


  static bool IsNonnegative(T val) { return val >= Zero; }



  static T ZeroValue() { return Zero; }
};







template <>
class NumericTraits<bool> : public std :: numeric_limits<bool> {
public:
  typedef bool ValueType;
  typedef bool PrintType;
  typedef unsigned char AbsType;
  typedef unsigned char AccumulateType;
  static const bool Zero;
  static const bool One;

  static bool NonpositiveMin() { return false; }
  static bool IsPositive(bool val) { return val; }
  static bool IsNonpositive(bool val) { return !val; }
  static bool IsNegative(bool ) { return false; }
  static bool IsNonnegative(bool ) {return true; }
  static bool ZeroValue() { return Zero; }
};





template <>
class NumericTraits<char> : public std :: numeric_limits<char> {
public:
  typedef char ValueType;
  typedef int PrintType;
  typedef unsigned char AbsType;
  typedef short AccumulateType;
  typedef double RealType;
  static const char Zero;
  static const char One;

  static char min() { return char(255) < 0 ? -128 : 0; }
  static char max() { return char(255) < 0 ? 127 : 255; }
  static char NonpositiveMin() { return NumericTraits<char>::min(); }
  static bool IsPositive(char val) { return val > Zero; }
  static bool IsNonpositive(char val) { return val <= Zero; }
  static bool IsNegative(char val) { return val < Zero; }
  static bool IsNonnegative(char val) {return val >= Zero; }
  static char ZeroValue() { return Zero; }
};





template <>
class NumericTraits<signed char> : public std :: numeric_limits<signed char> {
public:
  typedef signed char ValueType;
  typedef int PrintType;
  typedef unsigned char AbsType;
  typedef short AccumulateType;
  typedef double RealType;
  static const signed char Zero;
  static const signed char One;

  static signed char min() { return -128; }
  static signed char max() { return 127; }
  static signed char NonpositiveMin() { return NumericTraits<signed char>::min(); }
  static bool IsPositive(signed char val) { return val > Zero; }
  static bool IsNonpositive(signed char val) { return val <= Zero; }
  static bool IsNegative(signed char val) { return val < Zero; }
  static bool IsNonnegative(signed char val) {return val >= Zero; }
  static signed char ZeroValue() { return Zero; }
};





template <>
class NumericTraits<unsigned char> : public std :: numeric_limits<unsigned char> {
public:
  typedef unsigned char ValueType;
  typedef int PrintType;
  typedef unsigned char AbsType;
  typedef unsigned short AccumulateType;
  typedef double RealType;
  static const unsigned char Zero;
  static const unsigned char One;

  static unsigned char NonpositiveMin() { return NumericTraits<unsigned char>::min(); }
  static bool IsPositive(unsigned char val) { return val != Zero; }
  static bool IsNonpositive(unsigned char val) { return val == Zero; }
  static bool IsNegative(unsigned char ) { return false; }
  static bool IsNonnegative(unsigned char ) {return true; }
  static unsigned char ZeroValue() { return Zero; }
};




template <>
class NumericTraits<short> : public std :: numeric_limits<short> {
public:
  typedef short ValueType;
  typedef short PrintType;
  typedef unsigned short AbsType;
  typedef int AccumulateType;
  typedef double RealType;
  static const short Zero;
  static const short One;

  static short NonpositiveMin() { return NumericTraits<short>::min(); }
  static bool IsPositive(short val) { return val > Zero; }
  static bool IsNonpositive(short val) { return val <= Zero; }
  static bool IsNegative(short val) { return val < Zero; }
  static bool IsNonnegative(short val) {return val >= Zero; }
  static short ZeroValue() { return Zero; }
};





template <>
class NumericTraits<unsigned short> : public std :: numeric_limits<unsigned short> {
public:
  typedef unsigned short ValueType;
  typedef unsigned short PrintType;
  typedef unsigned short AbsType;
  typedef unsigned int AccumulateType;
  typedef double RealType;
  static const unsigned short Zero;
  static const unsigned short One;

  static unsigned short NonpositiveMin() { return NumericTraits<unsigned short>::min(); }
  static unsigned short IsPositive(unsigned short val) { return val != Zero; }
  static bool IsNonpositive(unsigned short val) { return val == Zero; }
  static bool IsNegative(unsigned short ) { return false; }
  static bool IsNonnegative(unsigned short ) {return true; }
  static unsigned short ZeroValue() { return Zero; }
};




template <>
class NumericTraits<int> : public std :: numeric_limits<int> {
public:
  typedef int ValueType;
  typedef int PrintType;
  typedef unsigned int AbsType;
  typedef long AccumulateType;
  typedef double RealType;
  static const int Zero;
  static const int One;

  static int NonpositiveMin() { return NumericTraits<int>::min(); }
  static bool IsPositive(int val) { return val > Zero; }
  static bool IsNonpositive(int val) { return val <= Zero; }
  static bool IsNegative(int val) { return val < Zero; }
  static bool IsNonnegative(int val) {return val >= Zero; }
  static int ZeroValue() { return Zero; }
};





template <>
class NumericTraits<unsigned int> : public std :: numeric_limits<unsigned int> {
public:
  typedef unsigned int ValueType;
  typedef unsigned int PrintType;
  typedef unsigned int AbsType;
  typedef unsigned int AccumulateType;
  typedef double RealType;
  static const unsigned int Zero;
  static const unsigned int One;

  static unsigned int min(void) { return 0; }
  static unsigned int max(void) { return static_cast<unsigned int>( -1 ); }
  static unsigned int NonpositiveMin() { return 0; }
  static bool IsPositive(unsigned int val) { return val != Zero; }
  static bool IsNonpositive(unsigned int val) { return val == Zero; }
  static bool IsNegative(unsigned int ) { return false; }
  static bool IsNonnegative(unsigned int ) {return true; }
  static unsigned int ZeroValue() { return Zero; }
};





template <>
class NumericTraits<long> : public std :: numeric_limits<long> {
public:
  typedef long ValueType;
  typedef long PrintType;
  typedef unsigned long AbsType;
  typedef long AccumulateType;
  typedef double RealType;
  static const long Zero;
  static const long One;

  static long NonpositiveMin() { return NumericTraits<long>::min(); }
  static bool IsPositive(long val) { return val > Zero; }
  static bool IsNonpositive(long val) { return val <= Zero; }
  static bool IsNegative(long val) { return val < Zero; }
  static bool IsNonnegative(long val) {return val >= Zero; }
  static long ZeroValue() { return Zero; }
};





template <>
class NumericTraits<unsigned long> : public std :: numeric_limits<unsigned long> {
public:
  typedef unsigned long ValueType;
  typedef unsigned long PrintType;
  typedef unsigned long AbsType;
  typedef unsigned long AccumulateType;
  typedef double RealType;
  static const unsigned long Zero;
  static const unsigned long One;

  static unsigned long NonpositiveMin() { return NumericTraits<unsigned long>::min(); }
  static bool IsPositive(unsigned long val) { return val != Zero; }
  static bool IsNonpositive(unsigned long val) { return val == Zero; }
  static bool IsNegative(unsigned long) { return false; }
  static bool IsNonnegative(unsigned long) {return true; }
  static unsigned long ZeroValue() { return Zero; }
};





template <>
class NumericTraits<float> : public std :: numeric_limits<float> {
public:
  typedef float ValueType;
  typedef float PrintType;
  typedef float AbsType;
  typedef double AccumulateType;
  typedef double RealType;
  static const float Zero;
  static const float One;

  static float NonpositiveMin() { return -max(); }
  static bool IsPositive(float val) { return val > Zero; }
  static bool IsNonpositive(float val) { return val <= Zero; }
  static bool IsNegative(float val) { return val < Zero; }
  static bool IsNonnegative(float val) {return val >= Zero; }
  static float ZeroValue() { return Zero; }
};





template <>
class NumericTraits<double> : public std :: numeric_limits<double> {
public:
  typedef double ValueType;
  typedef double PrintType;
  typedef double AbsType;
  typedef double AccumulateType;
  typedef double RealType;
  static const double Zero;
  static const double One;

  static double NonpositiveMin() { return -max(); }
  static bool IsPositive(double val) { return val > Zero; }
  static bool IsNonpositive(double val) { return val <= Zero; }
  static bool IsNegative(double val) { return val < Zero; }
  static bool IsNonnegative(double val) {return val >= Zero; }
  static double ZeroValue() { return Zero; }
};





template <>
class NumericTraits<long double> : public std :: numeric_limits<long double> {
public:
  typedef long double ValueType;
  typedef long double PrintType;
  typedef long double AbsType;
  typedef long double AccumulateType;
  typedef long double RealType;
  static const long double Zero;
  static const long double One;

  static long double NonpositiveMin() { return -max(); }
  static bool IsPositive(long double val) { return val > Zero; }
  static bool IsNonpositive(long double val) { return val <= Zero; }
  static bool IsNegative(long double val) { return val < Zero; }
  static bool IsNonnegative(long double val) {return val >= Zero; }
  static long double ZeroValue() { return Zero; }
};


}
# 22 "/tmp/installed/include/InsightToolkit/Common/itkVector.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_ref.h" 1


#define vnl_vector_ref_h_ 
# 20 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_ref.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h" 1


#define vnl_vector_h_ 
# 17 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_iosfwd.h" 1


#define vcl_iosfwd_h_ 
# 28 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_iosfwd.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_iosfwd.h" 1

#define vcl_iso_iosfwd_h_ 
# 11 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_iosfwd.h"
#define vcl_generic_iosfwd_STD std


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_iosfwd.h" 1

#define vcl_generic_iosfwd_h_ 





#define vcl_streamoff vcl_generic_iosfwd_STD :: streamoff



#define vcl_char_traits vcl_generic_iosfwd_STD :: char_traits



#define vcl_allocator vcl_generic_iosfwd_STD :: allocator



#define vcl_basic_ios vcl_generic_iosfwd_STD :: basic_ios



#define vcl_basic_streambuf vcl_generic_iosfwd_STD :: basic_streambuf



#define vcl_basic_istream vcl_generic_iosfwd_STD :: basic_istream



#define vcl_basic_ostream vcl_generic_iosfwd_STD :: basic_ostream



#define vcl_basic_iostream vcl_generic_iosfwd_STD :: basic_iostream



#define vcl_basic_stringbuf vcl_generic_iosfwd_STD :: basic_stringbuf



#define vcl_basic_istringstream vcl_generic_iosfwd_STD :: basic_istringstream



#define vcl_basic_ostringstream vcl_generic_iosfwd_STD :: basic_ostringstream



#define vcl_basic_filebuf vcl_generic_iosfwd_STD :: basic_filebuf



#define vcl_basic_ifstream vcl_generic_iosfwd_STD :: basic_ifstream



#define vcl_basic_ofstream vcl_generic_iosfwd_STD :: basic_ofstream



#define vcl_basic_fstream vcl_generic_iosfwd_STD :: basic_fstream



#define vcl_istreambuf_iterator vcl_generic_iosfwd_STD :: istreambuf_iterator



#define vcl_ostreambuf_iterator vcl_generic_iosfwd_STD :: ostreambuf_iterator



#define vcl_ios vcl_generic_iosfwd_STD :: ios



#define vcl_wios vcl_generic_iosfwd_STD :: wios



#define vcl_streambuf vcl_generic_iosfwd_STD :: streambuf



#define vcl_istream vcl_generic_iosfwd_STD :: istream



#define vcl_ostream vcl_generic_iosfwd_STD :: ostream



#define vcl_iostream vcl_generic_iosfwd_STD :: iostream



#define vcl_stringbuf vcl_generic_iosfwd_STD :: stringbuf



#define vcl_istringstream vcl_generic_iosfwd_STD :: istringstream



#define vcl_ostringstream vcl_generic_iosfwd_STD :: ostringstream



#define vcl_stringstream vcl_generic_iosfwd_STD :: stringstream



#define vcl_filebuf vcl_generic_iosfwd_STD :: filebuf



#define vcl_ifstream vcl_generic_iosfwd_STD :: ifstream



#define vcl_ofstream vcl_generic_iosfwd_STD :: ofstream



#define vcl_fstream vcl_generic_iosfwd_STD :: fstream



#define vcl_wstreambuf vcl_generic_iosfwd_STD :: wstreambuf



#define vcl_wistream vcl_generic_iosfwd_STD :: wistream



#define vcl_wostream vcl_generic_iosfwd_STD :: wostream



#define vcl_wiostream vcl_generic_iosfwd_STD :: wiostream



#define vcl_wstringbuf vcl_generic_iosfwd_STD :: wstringbuf



#define vcl_wistringstream vcl_generic_iosfwd_STD :: wistringstream



#define vcl_wostringstream vcl_generic_iosfwd_STD :: wostringstream



#define vcl_wstringstream vcl_generic_iosfwd_STD :: wstringstream



#define vcl_wfilebuf vcl_generic_iosfwd_STD :: wfilebuf



#define vcl_wifstream vcl_generic_iosfwd_STD :: wifstream



#define vcl_wofstream vcl_generic_iosfwd_STD :: wofstream



#define vcl_wfstream vcl_generic_iosfwd_STD :: wfstream



#define vcl_fpos vcl_generic_iosfwd_STD :: fpos



#define vcl_streampos vcl_generic_iosfwd_STD :: streampos



#define vcl_wstreampos vcl_generic_iosfwd_STD :: wstreampos
# 15 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_iosfwd.h" 2
# 29 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_iosfwd.h" 2
# 18 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_tag.h" 1


#define vnl_tag_h_ 
# 13 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_tag.h"
struct vnl_tag_add { };
struct vnl_tag_sub { };
struct vnl_tag_mul { };
struct vnl_tag_div { };
struct vnl_tag_grab { };
# 19 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_c_vector.h" 1


#define vnl_c_vector_h_ 
# 25 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_c_vector.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_numeric_traits.h" 1


#define vnl_numeric_traits_h_ 
# 29 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_numeric_traits.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vxl_config.h" 1

#define vxl_config_h_ 






#define VXL_LITTLE_ENDIAN 1
#define VXL_BIG_ENDIAN 0







#define VXL_HAS_BYTE 1
#define VXL_BYTE_STRING "char"

  typedef signed char vxl_sbyte;
  typedef unsigned char vxl_byte;





#define VXL_HAS_INT_8 1
#define VXL_INT_8_STRING "char"

  typedef char vxl_int_8;
  typedef signed char vxl_sint_8;
  typedef unsigned char vxl_uint_8;






#define VXL_HAS_INT_16 1
#define VXL_INT_16_STRING "short"

  typedef short vxl_int_16;
  typedef signed short vxl_sint_16;
  typedef unsigned short vxl_uint_16;






#define VXL_HAS_INT_32 1
#define VXL_INT_32_STRING "int"

  typedef int vxl_int_32;
  typedef signed int vxl_sint_32;
  typedef unsigned int vxl_uint_32;






#define VXL_HAS_INT_64 1
#define VXL_INT_64_STRING "long long"

  typedef long long vxl_int_64;
  typedef signed long long vxl_sint_64;
  typedef unsigned long long vxl_uint_64;






#define VXL_INT_64_IS_LONG 0

#define VXL_HAS_IEEE_32 1
#define VXL_IEEE_32_STRING "float"

  typedef float vxl_ieee_32;




#define VXL_HAS_IEEE_64 1
#define VXL_IEEE_64_STRING "double"

  typedef double vxl_ieee_64;




#define VXL_HAS_IEEE_96 1
#define VXL_IEEE_96_STRING "long double"

  typedef long double vxl_ieee_96;




#define VXL_HAS_IEEE_128 0
#define VXL_IEEE_128_STRING "void"



#define vxl_ieee_128 void




#define VXL_HAS_PTHREAD_H 1
#define VXL_HAS_SEMAPHORE_H 1






#define VXL_UNISTD_HAS_USECONDS_T 1
#define VXL_UNISTD_HAS_INTPTR_T 1
#define VXL_UNISTD_HAS_UALARM 1
#define VXL_UNISTD_HAS_USLEEP 1
#define VXL_UNISTD_HAS_LCHOWN 1
#define VXL_UNISTD_HAS_PREAD 1
#define VXL_UNISTD_HAS_PWRITE 1
#define VXL_UNISTD_HAS_TELL 0


#define VXL_STDLIB_HAS_QSORT 1


#define VXL_STDLIB_HAS_LRAND48 1


#define VXL_STDLIB_HAS_DRAND48 1


#define VXL_STDLIB_HAS_SRAND48 1


#define VXL_IEEEFP_HAS_FINITE 0


#define VXL_C_MATH_HAS_FINITEF 1


#define VXL_C_MATH_HAS_FINITE 1


#define VXL_C_MATH_HAS_FINITEL 1


#define VXL_C_MATH_HAS_SQRTF 1


#define VXL_UNISTD_USLEEP_IS_VOID 0


#define VXL_TWO_ARG_GETTIME 0


#define VXL_HAS_IEEEFP_H 0
# 30 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_numeric_traits.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.h" 1

#define vcl_complex_h_ 
# 62 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_complex.h" 1

#define vcl_iso_complex_h_ 



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/complex" 1 3
# 44 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/complex" 3
#define _CPP_COMPLEX 1

       
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/complex" 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/cpp_type_traits.h" 1 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/cpp_type_traits.h" 3
#define _CPP_BITS_CPP_TYPE_TRAITS_H 1

       
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/cpp_type_traits.h" 3
# 67 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/cpp_type_traits.h" 3
namespace std
{
  template<typename _Tp>
    struct __is_void
    {
      enum
      {
        _M_type = 0
      };
    };

  template<>
    struct __is_void<void>
    {
      enum
      {
        _M_type = 1
      };
    };




  template<typename _Tp>
    struct __is_integer
    {
      enum
      {
        _M_type = 0
      };
    };




  template<>
    struct __is_integer<bool>
    {
      enum
      {
        _M_type = 1
      };
    };

  template<>
    struct __is_integer<char>
    {
      enum
      {
        _M_type = 1
      };
    };

  template<>
    struct __is_integer<signed char>
    {
      enum
      {
        _M_type = 1
      };
    };

  template<>
  struct __is_integer<unsigned char>
  {
    enum
    {
      _M_type = 1
    };
  };


  template<>
  struct __is_integer<wchar_t>
  {
    enum
    {
      _M_type = 1
    };
  };


  template<>
  struct __is_integer<short>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_integer<unsigned short>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_integer<int>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_integer<unsigned int>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_integer<long>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_integer<unsigned long>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_integer<long long>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_integer<unsigned long long>
  {
    enum
    {
      _M_type = 1
    };
  };




  template<typename _Tp>
  struct __is_floating
  {
    enum
    {
      _M_type = 0
    };
  };


  template<>
  struct __is_floating<float>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_floating<double>
  {
    enum
    {
      _M_type = 1
    };
  };

  template<>
  struct __is_floating<long double>
  {
    enum
    {
      _M_type = 1
    };
  };




  template<typename _Tp>
  struct __is_arithmetic
  {
    enum
    {
      _M_type = __is_integer<_Tp>::_M_type || __is_floating<_Tp>::_M_type
    };
  };




  template<typename _Tp>
  struct __is_fundamental
  {
    enum
    {
      _M_type = __is_void<_Tp>::_M_type || __is_arithmetic<_Tp>::_M_type
    };
  };




  template<typename _Tp>
  struct __is_pod
  {
    enum
    {
      _M_type = __is_fundamental<_Tp>::_M_type
    };
  };

}
# 50 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/complex" 2 3



namespace std
{

  template<typename _Tp> class complex;
  template<> class complex<float>;
  template<> class complex<double>;
  template<> class complex<long double>;

  template<typename _Tp> _Tp abs(const complex<_Tp>&);
  template<typename _Tp> _Tp arg(const complex<_Tp>&);
  template<typename _Tp> _Tp norm(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);


  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
                                           const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);



  template<typename _Tp>
    class complex
    {
    public:
      typedef _Tp value_type;

      complex(const _Tp& = _Tp(), const _Tp & = _Tp());



      template<typename _Up>
        complex(const complex<_Up>&);

      _Tp real() const;
      _Tp imag() const;

      complex<_Tp>& operator=(const _Tp&);
      complex<_Tp>& operator+=(const _Tp&);
      complex<_Tp>& operator-=(const _Tp&);
      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>&);

    private:
      _Tp _M_real, _M_imag;
    };

  template<typename _Tp>
    inline _Tp
    complex<_Tp>::real() const { return _M_real; }

  template<typename _Tp>
    inline _Tp
    complex<_Tp>::imag() const { return _M_imag; }

  template<typename _Tp>
    inline
    complex<_Tp>::complex(const _Tp& __r, const _Tp& __i)
    : _M_real(__r), _M_imag(__i) { }

  template<typename _Tp>
    template<typename _Up>
    inline
    complex<_Tp>::complex(const complex<_Up>& __z)
    : _M_real(__z.real()), _M_imag(__z.imag()) { }

  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator=(const _Tp& __t)
    {
     _M_real = __t;
     _M_imag = _Tp();
     return *this;
    }


  template<typename _Tp>
    inline complex<_Tp>&
    complex<_Tp>::operator+=(const _Tp& __t)
    {
      _M_real += __t;
      return *this;
    }


  template<typename _Tp>
    inline complex<_Tp>&
    complex<_Tp>::operator-=(const _Tp& __t)
    {
      _M_real -= __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>
    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 = 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)
    { return complex<_Tp> (__x) += __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x, const _Tp& __y)
    { return complex<_Tp> (__x) += __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const _Tp& __x, const complex<_Tp>& __y)
    { return complex<_Tp> (__y) += __x; }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return complex<_Tp> (__x) -= __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const _Tp& __y)
    { return complex<_Tp> (__x) -= __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const _Tp& __x, const complex<_Tp>& __y)
    { return complex<_Tp> (__x) -= __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return complex<_Tp> (__x) *= __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const _Tp& __y)
    { return complex<_Tp> (__x) *= __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const _Tp& __x, const complex<_Tp>& __y)
    { return complex<_Tp> (__y) *= __x; }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return complex<_Tp> (__x) /= __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const _Tp& __y)
    { return complex<_Tp> (__x) /= __y; }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const _Tp& __x, const complex<_Tp>& __y)
    { return complex<_Tp> (__x) /= __y; }

  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 = complex<_Tp>(__re_x, _Tp(0));
          else
            __is.setstate(ios_base::failbit);
        }
      else
        {
          __is.putback(__ch);
          __is >> __re_x;
          __x = complex<_Tp>(__re_x, _Tp(0));
        }
      return __is;
    }

  template<typename _Tp, typename _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
    {
      basic_ostringstream<_CharT, _Traits> __s;
      __s.flags(__os.flags());
      __s.imbue(__os.getloc());
      __s.precision(__os.precision());
      __s << '(' << __x.real() << ',' << __x.imag() << ')';
      return __os << __s.str();
    }


  template<typename _Tp>
    inline _Tp
    real(const complex<_Tp>& __z)
    { return __z.real(); }

  template<typename _Tp>
    inline _Tp
    imag(const complex<_Tp>& __z)
    { return __z.imag(); }

  template<typename _Tp>
    inline _Tp
    abs(const complex<_Tp>& __z)
    {
      _Tp __x = __z.real();
      _Tp __y = __z.imag();
      const _Tp __s = max(abs(__x), abs(__y));
      if (__s == _Tp())
        return __s;
      __x /= __s;
      __y /= __s;
      return __s * sqrt(__x * __x + __y * __y);
    }

  template<typename _Tp>
    inline _Tp
    arg(const complex<_Tp>& __z)
    { return atan2(__z.imag(), __z.real()); }






  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 = abs(__z);
          return __res * __res;
        }
    };

  template<typename _Tp>
    inline _Tp
    norm(const complex<_Tp>& __z)
    {
      return _Norm_helper<__is_floating<_Tp>::_M_type && !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>
    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));
    }

  template<typename _Tp>
    inline complex<_Tp>
    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));
    }

  template<typename _Tp>
    inline complex<_Tp>
    exp(const complex<_Tp>& __z)
    { return polar(exp(__z.real()), __z.imag()); }

  template<typename _Tp>
    inline complex<_Tp>
    log(const complex<_Tp>& __z)
    { return complex<_Tp>(log(abs(__z)), arg(__z)); }

  template<typename _Tp>
    inline complex<_Tp>
    log10(const complex<_Tp>& __z)
    { return log(__z) / log(_Tp(10.0)); }

  template<typename _Tp>
    inline complex<_Tp>
    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));
    }

  template<typename _Tp>
    inline complex<_Tp>
    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));
    }

  template<typename _Tp>
    complex<_Tp>
    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 * (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);
        }
    }

  template<typename _Tp>
    inline complex<_Tp>
    tan(const complex<_Tp>& __z)
    {
      return sin(__z) / cos(__z);
    }

  template<typename _Tp>
    inline complex<_Tp>
    tanh(const complex<_Tp>& __z)
    {
      return sinh(__z) / cosh(__z);
    }

  template<typename _Tp>
    inline complex<_Tp>
    pow(const complex<_Tp>& __z, int __n)
    {
      return __pow_helper(__z, __n);
    }

  template<typename _Tp>
    complex<_Tp>
    pow(const complex<_Tp>& __x, const _Tp& __y)
    {
      if (__x.imag() == _Tp())
        return pow(__x.real(), __y);

      complex<_Tp> __t = log(__x);
      return polar(exp(__y * __t.real()), __y * __t.imag());
    }

  template<typename _Tp>
    inline complex<_Tp>
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      return __x == _Tp() ? _Tp() : exp(__y * log(__x));
    }

  template<typename _Tp>
    inline complex<_Tp>
    pow(const _Tp& __x, const complex<_Tp>& __y)
    {
      return __x == _Tp()
        ? _Tp()
        : polar(pow(__x, __y.real()), __y.imag() * log(__x));
    }



  template<> class complex<float>
  {
  public:
    typedef float value_type;

    complex(float = 0.0f, float = 0.0f);



    explicit complex(const complex<double>&);
    explicit complex(const complex<long double>&);

    float real() const;
    float imag() const;

    complex<float>& operator=(float);
    complex<float>& operator+=(float);
    complex<float>& operator-=(float);
    complex<float>& operator*=(float);
    complex<float>& operator/=(float);




    template<typename _Tp>
      complex<float>&operator=(const complex<_Tp>&);
    template<typename _Tp>
      complex<float>& operator+=(const complex<_Tp>&);
    template<class _Tp>
      complex<float>& operator-=(const complex<_Tp>&);
    template<class _Tp>
      complex<float>& operator*=(const complex<_Tp>&);
    template<class _Tp>
      complex<float>&operator/=(const complex<_Tp>&);

  private:
    typedef __complex__ float _ComplexT;
    _ComplexT _M_value;

    complex(_ComplexT __z) : _M_value(__z) { }

    friend class complex<double>;
    friend class complex<long double>;
  };

  inline float
  complex<float>::real() const
  { return __real__ _M_value; }

  inline float
  complex<float>::imag() const
  { return __imag__ _M_value; }

  inline
  complex<float>::complex(float r, float i)
  {
    __real__ _M_value = r;
    __imag__ _M_value = i;
  }

  inline complex<float>&
  complex<float>::operator=(float __f)
  {
    __real__ _M_value = __f;
    __imag__ _M_value = 0.0f;
    return *this;
  }

  inline complex<float>&
  complex<float>::operator+=(float __f)
  {
    __real__ _M_value += __f;
    return *this;
  }

  inline complex<float>&
  complex<float>::operator-=(float __f)
  {
    __real__ _M_value -= __f;
    return *this;
  }

  inline complex<float>&
  complex<float>::operator*=(float __f)
  {
    _M_value *= __f;
    return *this;
  }

  inline complex<float>&
  complex<float>::operator/=(float __f)
  {
    _M_value /= __f;
    return *this;
  }

  template<typename _Tp>
  inline complex<float>&
  complex<float>::operator=(const complex<_Tp>& __z)
  {
    __real__ _M_value = __z.real();
    __imag__ _M_value = __z.imag();
    return *this;
  }

  template<typename _Tp>
  inline complex<float>&
  complex<float>::operator+=(const complex<_Tp>& __z)
  {
    __real__ _M_value += __z.real();
    __imag__ _M_value += __z.imag();
    return *this;
  }

  template<typename _Tp>
    inline complex<float>&
    complex<float>::operator-=(const complex<_Tp>& __z)
    {
     __real__ _M_value -= __z.real();
     __imag__ _M_value -= __z.imag();
     return *this;
    }

  template<typename _Tp>
    inline complex<float>&
    complex<float>::operator*=(const complex<_Tp>& __z)
    {
      _ComplexT __t;
      __real__ __t = __z.real();
      __imag__ __t = __z.imag();
      _M_value *= __t;
      return *this;
    }

  template<typename _Tp>
    inline complex<float>&
    complex<float>::operator/=(const complex<_Tp>& __z)
    {
      _ComplexT __t;
      __real__ __t = __z.real();
      __imag__ __t = __z.imag();
      _M_value /= __t;
      return *this;
    }



  template<> class complex<double>
  {
  public:
    typedef double value_type;

    complex(double =0.0, double =0.0);



    complex(const complex<float>&);
    explicit complex(const complex<long double>&);

    double real() const;
    double imag() const;

    complex<double>& operator=(double);
    complex<double>& operator+=(double);
    complex<double>& operator-=(double);
    complex<double>& operator*=(double);
    complex<double>& operator/=(double);



    template<typename _Tp>
      complex<double>& operator=(const complex<_Tp>&);
    template<typename _Tp>
      complex<double>& operator+=(const complex<_Tp>&);
    template<typename _Tp>
      complex<double>& operator-=(const complex<_Tp>&);
    template<typename _Tp>
      complex<double>& operator*=(const complex<_Tp>&);
    template<typename _Tp>
      complex<double>& operator/=(const complex<_Tp>&);

  private:
    typedef __complex__ double _ComplexT;
    _ComplexT _M_value;

    complex(_ComplexT __z) : _M_value(__z) { }

    friend class complex<float>;
    friend class complex<long double>;
  };

  inline double
  complex<double>::real() const
  { return __real__ _M_value; }

  inline double
  complex<double>::imag() const
  { return __imag__ _M_value; }

  inline
  complex<double>::complex(double __r, double __i)
  {
    __real__ _M_value = __r;
    __imag__ _M_value = __i;
  }

  inline complex<double>&
  complex<double>::operator=(double __d)
  {
    __real__ _M_value = __d;
    __imag__ _M_value = 0.0;
    return *this;
  }

  inline complex<double>&
  complex<double>::operator+=(double __d)
  {
    __real__ _M_value += __d;
    return *this;
  }

  inline complex<double>&
  complex<double>::operator-=(double __d)
  {
    __real__ _M_value -= __d;
    return *this;
  }

  inline complex<double>&
  complex<double>::operator*=(double __d)
  {
    _M_value *= __d;
    return *this;
  }

  inline complex<double>&
  complex<double>::operator/=(double __d)
  {
    _M_value /= __d;
    return *this;
  }

  template<typename _Tp>
    inline complex<double>&
    complex<double>::operator=(const complex<_Tp>& __z)
    {
      __real__ _M_value = __z.real();
      __imag__ _M_value = __z.imag();
      return *this;
    }

  template<typename _Tp>
    inline complex<double>&
    complex<double>::operator+=(const complex<_Tp>& __z)
    {
      __real__ _M_value += __z.real();
      __imag__ _M_value += __z.imag();
      return *this;
    }

  template<typename _Tp>
    inline complex<double>&
    complex<double>::operator-=(const complex<_Tp>& __z)
    {
      __real__ _M_value -= __z.real();
      __imag__ _M_value -= __z.imag();
      return *this;
    }

  template<typename _Tp>
    inline complex<double>&
    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>
    inline complex<double>&
    complex<double>::operator/=(const complex<_Tp>& __z)
    {
      _ComplexT __t;
      __real__ __t = __z.real();
      __imag__ __t = __z.imag();
      _M_value /= __t;
      return *this;
    }



  template<> class complex<long double>
  {
  public:
    typedef long double value_type;

    complex(long double = 0.0L, long double = 0.0L);



    complex(const complex<float>&);
    complex(const complex<double>&);

    long double real() const;
    long double imag() const;

    complex<long double>& operator= (long double);
    complex<long double>& operator+= (long double);
    complex<long double>& operator-= (long double);
    complex<long double>& operator*= (long double);
    complex<long double>& operator/= (long double);



    template<typename _Tp>
      complex<long double>& operator=(const complex<_Tp>&);
    template<typename _Tp>
      complex<long double>& operator+=(const complex<_Tp>&);
    template<typename _Tp>
      complex<long double>& operator-=(const complex<_Tp>&);
    template<typename _Tp>
      complex<long double>& operator*=(const complex<_Tp>&);
    template<typename _Tp>
      complex<long double>& operator/=(const complex<_Tp>&);

  private:
    typedef __complex__ long double _ComplexT;
    _ComplexT _M_value;

    complex(_ComplexT __z) : _M_value(__z) { }

    friend class complex<float>;
    friend class complex<double>;
  };

  inline
  complex<long double>::complex(long double __r, long double __i)
  {
    __real__ _M_value = __r;
    __imag__ _M_value = __i;
  }

  inline long double
  complex<long double>::real() const
  { return __real__ _M_value; }

  inline long double
  complex<long double>::imag() const
  { return __imag__ _M_value; }

  inline complex<long double>&
  complex<long double>::operator=(long double __r)
  {
    __real__ _M_value = __r;
    __imag__ _M_value = 0.0L;
    return *this;
  }

  inline complex<long double>&
  complex<long double>::operator+=(long double __r)
  {
    __real__ _M_value += __r;
    return *this;
  }

  inline complex<long double>&
  complex<long double>::operator-=(long double __r)
  {
    __real__ _M_value -= __r;
    return *this;
  }

  inline complex<long double>&
  complex<long double>::operator*=(long double __r)
  {
    _M_value *= __r;
    return *this;
  }

  inline complex<long double>&
  complex<long double>::operator/=(long double __r)
  {
    _M_value /= __r;
    return *this;
  }

  template<typename _Tp>
    inline complex<long double>&
    complex<long double>::operator=(const complex<_Tp>& __z)
    {
      __real__ _M_value = __z.real();
      __imag__ _M_value = __z.imag();
      return *this;
    }

  template<typename _Tp>
    inline complex<long double>&
    complex<long double>::operator+=(const complex<_Tp>& __z)
    {
      __real__ _M_value += __z.real();
      __imag__ _M_value += __z.imag();
      return *this;
    }

  template<typename _Tp>
    inline complex<long double>&
    complex<long double>::operator-=(const complex<_Tp>& __z)
    {
      __real__ _M_value -= __z.real();
      __imag__ _M_value -= __z.imag();
      return *this;
    }

  template<typename _Tp>
    inline complex<long double>&
    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>
    inline complex<long double>&
    complex<long double>::operator/=(const complex<_Tp>& __z)
    {
      _ComplexT __t;
      __real__ __t = __z.real();
      __imag__ __t = __z.imag();
      _M_value /= __t;
      return *this;
    }





  inline
  complex<float>::complex(const complex<double>& __z)
  : _M_value(_ComplexT(__z._M_value)) { }

  inline
  complex<float>::complex(const complex<long double>& __z)
  : _M_value(_ComplexT(__z._M_value)) { }

  inline
  complex<double>::complex(const complex<float>& __z)
  : _M_value(_ComplexT(__z._M_value)) { }

  inline
  complex<double>::complex(const complex<long double>& __z)
  {
    __real__ _M_value = __z.real();
    __imag__ _M_value = __z.imag();
  }

  inline
  complex<long double>::complex(const complex<float>& __z)
  : _M_value(_ComplexT(__z._M_value)) { }

  inline
  complex<long double>::complex(const complex<double>& __z)
  : _M_value(_ComplexT(__z._M_value)) { }
}
# 7 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_complex.h" 2




#define vcl_generic_complex_STD std


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_complex.h" 1

#define vcl_generic_complex_h_ 





#define vcl_complex vcl_generic_complex_STD :: complex



#define vcl_real vcl_generic_complex_STD :: real



#define vcl_imag vcl_generic_complex_STD :: imag



#define vcl_abs vcl_generic_complex_STD :: abs



#define vcl_arg vcl_generic_complex_STD :: arg



#define vcl_norm vcl_generic_complex_STD :: norm



#define vcl_conj vcl_generic_complex_STD :: conj



#define vcl_polar vcl_generic_complex_STD :: polar



#define vcl_cos vcl_generic_complex_STD :: cos



#define vcl_cosh vcl_generic_complex_STD :: cosh



#define vcl_exp vcl_generic_complex_STD :: exp



#define vcl_log vcl_generic_complex_STD :: log



#define vcl_log10 vcl_generic_complex_STD :: log10



#define vcl_pow vcl_generic_complex_STD :: pow



#define vcl_sin vcl_generic_complex_STD :: sin



#define vcl_sinh vcl_generic_complex_STD :: sinh



#define vcl_sqrt vcl_generic_complex_STD :: sqrt



#define vcl_tan vcl_generic_complex_STD :: tan



#define vcl_tanh vcl_generic_complex_STD :: tanh
# 15 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_complex.h" 2
# 63 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.h" 2
# 79 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.h"
#define VCL_COMPLEX_INSTANTIATE(T) extern "you must include vcl_complex.txx instead"


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.txx" 1

#define vcl_complex_txx_ 


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.h" 1
# 6 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.txx" 2


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_complex.txx" 1

#define vcl_iso_complex_txx_ 



#undef VCL_COMPLEX_INSTANTIATE
#define VCL_COMPLEX_INSTANTIATE(T) 
# 9 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.txx" 2
# 83 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_complex.h" 2
# 31 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_numeric_traits.h" 2




template <class T>
class vnl_numeric_traits;
# 69 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_numeric_traits.h"
template <>
class vnl_numeric_traits<bool>
{
 public:

  static const bool zero = false;

  static const bool one = true;

  static const bool maxval = true;

  typedef unsigned int abs_t;

  typedef unsigned int double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<bool const> : public vnl_numeric_traits<bool> {};



template <>
class vnl_numeric_traits<char>
{
 public:

  static const char zero = 0;

  static const char one = 1;


  static const char maxval = char(255)<0?127:255;

  typedef unsigned char abs_t;

  typedef short double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<char const> : public vnl_numeric_traits<char> {};


template <>
class vnl_numeric_traits<unsigned char>
{
 public:

  static const unsigned char zero = 0;

  static const unsigned char one = 1;

  static const unsigned char maxval = 255;

  typedef unsigned char abs_t;

  typedef unsigned short double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<unsigned char const> : public vnl_numeric_traits<unsigned char> {};


template <>
class vnl_numeric_traits<signed char>
{
 public:

  static const signed char zero = 0;

  static const signed char one = 1;

  static const signed char maxval = 127;

  typedef unsigned char abs_t;

  typedef signed short double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<signed char const> : public vnl_numeric_traits<signed char> {};


template <>
class vnl_numeric_traits<short>
{
 public:

  static const short zero = 0;

  static const short one = 1;

  static const short maxval;

  typedef unsigned short abs_t;

  typedef int double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<short const> : public vnl_numeric_traits<short> {};


template <>
class vnl_numeric_traits<unsigned short>
{
 public:

  static const unsigned short zero = 0;

  static const unsigned short one = 1;

  static const unsigned short maxval;

  typedef unsigned short abs_t;

  typedef unsigned int double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<unsigned short const> : public vnl_numeric_traits<unsigned short> {};


template <>
class vnl_numeric_traits<int>
{
 public:

  static const int zero = 0;

  static const int one = 1;

  static const int maxval;

  typedef unsigned int abs_t;

  typedef long double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<int const> : public vnl_numeric_traits<int> {};


template <>
class vnl_numeric_traits<unsigned int>
{
 public:

  static const unsigned int zero = 0;

  static const unsigned int one = 1;

  static const unsigned int maxval;

  typedef unsigned int abs_t;

  typedef unsigned long double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<unsigned int const> : public vnl_numeric_traits<unsigned int> {};


template <>
class vnl_numeric_traits<long>
{
 public:

  static const long zero = 0;

  static const long one = 1;

  static const long maxval;

  typedef unsigned long abs_t;

  typedef vxl_sint_64 double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<long const> : public vnl_numeric_traits<long > {};


template <>
class vnl_numeric_traits<unsigned long>
{
 public:

  static const unsigned long zero = 0;

  static const unsigned long one = 1;

  static const unsigned long maxval;

  typedef unsigned long abs_t;

  typedef vxl_uint_64 double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<unsigned long const> : public vnl_numeric_traits<unsigned long> {};


template <>
class vnl_numeric_traits<float>
{
 public:

  static const float zero = 0.0F;

  static const float one = 1.0F;

  static const float maxval = 3.40282346638528860e+38F;

  typedef float abs_t;

  typedef double double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<float const> : public vnl_numeric_traits<float> {};


template <>
class vnl_numeric_traits<double>
{
 public:

  static const double zero = 0.0;

  static const double one = 1.0;

  static const double maxval = 1.7976931348623157E+308;

  typedef double abs_t;

  typedef long double double_t;

  typedef double real_t;
};


template <>
class vnl_numeric_traits<double const> : public vnl_numeric_traits<double> {};


template <>
class vnl_numeric_traits<long double>
{
 public:

  static const long double zero = 0.0;

  static const long double one = 1.0;

  static const long double maxval = 1.7976931348623157E+308;

  typedef long double abs_t;

  typedef long double double_t;

  typedef long double real_t;
};


template <>
class vnl_numeric_traits<long double const> : public vnl_numeric_traits<long double> {};


template <>
class vnl_numeric_traits< std :: complex<float> >
{
 public:

  static const std :: complex<float> zero;

  static const std :: complex<float> one;




  typedef float abs_t;

  typedef std :: complex<vnl_numeric_traits<float>::double_t> double_t;

  typedef std :: complex<float> real_t;
};


template <>
class vnl_numeric_traits<std :: complex<float> const> : public vnl_numeric_traits<std :: complex<float> > {};


template <>
class vnl_numeric_traits< std :: complex<double> >
{
 public:

  static const std :: complex<double> zero;

  static const std :: complex<double> one;




  typedef double abs_t;

  typedef std :: complex<vnl_numeric_traits<double>::double_t> double_t;

  typedef std :: complex<double> real_t;
};


template <>
class vnl_numeric_traits<std :: complex<double> const> : public vnl_numeric_traits<std :: complex<double> > {};


template <>
class vnl_numeric_traits< std :: complex<long double> >
{
 public:

  static const std :: complex<long double> zero;

  static const std :: complex<long double> one;




  typedef long double abs_t;

  typedef std :: complex<vnl_numeric_traits<long double>::double_t> double_t;

  typedef std :: complex<long double> real_t;
};


template <>
class vnl_numeric_traits<std :: complex<long double> const> : public vnl_numeric_traits<std :: complex<long double> > {};
# 26 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_c_vector.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cmath.h" 1

#define vcl_cmath_h_ 
# 45 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cmath.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/gcc/vcl_cmath.h" 1

#define vcl_gcc_cmath_h_ 

# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cmath.h" 1

#define vcl_iso_cmath_h_ 
# 11 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cmath.h"
#define vcl_generic_cmath_STD std


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_cmath.h" 1

#define vcl_generic_cmath_h_ 
# 12 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_cmath.h"
#define vcl_acos vcl_generic_cmath_STD :: acos



#define vcl_asin vcl_generic_cmath_STD :: asin



#define vcl_atan vcl_generic_cmath_STD :: atan



#define vcl_atan2 vcl_generic_cmath_STD :: atan2



#define vcl_ceil vcl_generic_cmath_STD :: ceil
# 44 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_cmath.h"
#define vcl_fabs vcl_generic_cmath_STD :: fabs



#define vcl_floor vcl_generic_cmath_STD :: floor



#define vcl_fmod vcl_generic_cmath_STD :: fmod



#define vcl_frexp vcl_generic_cmath_STD :: frexp



#define vcl_ldexp vcl_generic_cmath_STD :: ldexp
# 72 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_cmath.h"
#define vcl_modf vcl_generic_cmath_STD :: modf
# 15 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cmath.h" 2
# 5 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/gcc/vcl_cmath.h" 2
# 46 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cmath.h" 2
# 27 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_c_vector.h" 2


template <class T, class S> void vnl_c_vector_one_norm(T const *p, unsigned n, S *out);
template <class T, class S> void vnl_c_vector_two_norm(T const *p, unsigned n, S *out);
template <class T, class S> void vnl_c_vector_inf_norm(T const *p, unsigned n, S *out);
template <class T, class S> void vnl_c_vector_two_norm_squared(T const *p, unsigned n, S *out);
template <class T, class S> void vnl_c_vector_rms_norm(T const *p, unsigned n, S *out);


 template <class T>
class vnl_c_vector
{
 public:
  typedef typename vnl_numeric_traits<T>::abs_t abs_t;
  typedef typename vnl_numeric_traits<T>::real_t real_t;

  static T sum(T const* v, unsigned n);
  static inline abs_t squared_magnitude(T const *p, unsigned n)
    { abs_t val; vnl_c_vector_two_norm_squared(p, n, &val); return val; }
  static void normalize(T *, unsigned n);
  static void apply(T const *, unsigned, T (*f)(T), T* v_out);
  static void apply(T const *, unsigned, T (*f)(T const&), T* v_out);



  static void copy (T const *x, T *y, unsigned);


  static void scale (T const *x, T *y, unsigned, T const &);


  static void add (T const *x, T const *y, T *z, unsigned);


  static void add (T const *x, T const& y, T *z, unsigned);


  static void subtract(T const *x, T const *y, T *z, unsigned);


  static void subtract(T const *x, T const& y, T *z, unsigned);


  static void multiply(T const *x, T const *y, T *z, unsigned);


  static void multiply(T const *x, T const& y, T *z, unsigned);


  static void divide (T const *x, T const *y, T *z, unsigned);


  static void divide (T const *x, T const& y, T *z, unsigned);



  static void negate (T const *x, T *y, unsigned);


  static void invert (T const *x, T *y, unsigned);


  static void saxpy (T const &a, T const *x, T *y, unsigned);


  static void fill (T *x, unsigned, T const &v);


  static void reverse (T *x, unsigned);
  static T dot_product (T const *, T const *, unsigned);


  static T inner_product(T const *, T const *, unsigned);
  static void conjugate(T const *, T *, unsigned);

  static T max_value(T const *, unsigned);
  static T min_value(T const *, unsigned);

  static T mean(T const *p, unsigned n) { return sum(p,n)/abs_t(n); }




  static inline real_t std(T const *p, unsigned n) {
    return std :: sqrt(real_t(sum_sq_diff_means(p, n))/real_t(abs_t(n-1)));}


  static T sum_sq_diff_means(T const* v, unsigned n);


  static inline abs_t one_norm(T const *p, unsigned n)
    { abs_t val; vnl_c_vector_one_norm(p, n, &val); return val; }


  static inline abs_t two_norm(T const *p, unsigned n)
    { abs_t val; vnl_c_vector_two_norm(p, n, &val); return val; }


  static inline abs_t inf_norm(T const *p, unsigned n)
    { abs_t val; vnl_c_vector_inf_norm(p, n, &val); return val; }


  static inline abs_t two_nrm2(T const *p, unsigned n)
    { abs_t val; vnl_c_vector_two_norm_squared(p, n, &val); return val; }


  static inline abs_t rms_norm(T const *p, unsigned n)
    { abs_t val; vnl_c_vector_rms_norm(p, n, &val); return val; }



  static T euclid_dist_sq(T const *, T const *, unsigned);


  static T** allocate_Tptr(int n);
  static T* allocate_T(int n);
  static void deallocate(T**, int n_when_allocated);
  static void deallocate(T*, int n_when_allocated);
};



template <class T>
std :: ostream& print_vector(std :: ostream&, T const*, unsigned);
# 20 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h" 2

# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_error.h" 1


#define vnl_error_h_ 
# 12 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_error.h"
extern void vnl_error_vector_index (const char* fcn, int index);
extern void vnl_error_vector_dimension (const char* fcn, int l1, int l2);
extern void vnl_error_vector_va_arg (int n);


extern void vnl_error_matrix_row_index (char const* fcn, int r);
extern void vnl_error_matrix_col_index (char const* fcn, int c);
extern void vnl_error_matrix_dimension (char const* fcn, int r1, int c1, int r2, int c2);
extern void vnl_error_matrix_nonsquare (char const* fcn);
extern void vnl_error_matrix_va_arg (int n);
# 22 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_config.h" 1

#define vnl_config_h_ 







#define VNL_CONFIG_CHECK_BOUNDS 1


#define VNL_CONFIG_LEGACY_METHODS 0


#define VNL_CONFIG_THREAD_SAFE 1
# 23 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h" 2

# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cassert.h" 1
# 43 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cassert.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cassert.h" 1

#define vcl_iso_cassert_h_ 



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cassert" 1 3
# 46 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cassert" 3
       
# 47 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 35 "/usr/include/assert.h" 3 4
#define _ASSERT_H 1



#define __ASSERT_VOID_CAST static_cast<void>
# 65 "/usr/include/assert.h" 3 4
extern "C" {


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


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




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


}





#define assert(expr) (__ASSERT_VOID_CAST (__builtin_expect (!!(expr), 1) ? 0 : (__assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION), 0)))
# 104 "/usr/include/assert.h" 3 4
#define assert_perror(errnum) (__ASSERT_VOID_CAST (__builtin_expect (!(errnum), 1) ? 0 : (__assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION), 0)))
# 122 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 49 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/cassert" 2 3
# 7 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cassert.h" 2




#define vcl_generic_cassert_STD std


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_cassert.h" 1

#define vcl_generic_cassert_h_ 
# 15 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cassert.h" 2
# 44 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cassert.h" 2
# 25 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h" 2







 template <class T> class vnl_vector;
 template <class T> class vnl_matrix;



#define v vnl_vector<T>
#define m vnl_matrix<T>
template <class T> T dot_product (vnl_vector<T> const&, vnl_vector<T> const&);
template <class T> T inner_product (vnl_vector<T> const&, vnl_vector<T> const&);
template <class T> T bracket (vnl_vector<T> const &, vnl_matrix<T> const &, vnl_vector<T> const &);
template <class T> T cos_angle(vnl_vector<T> const&, vnl_vector<T> const& );
template <class T> double angle (vnl_vector<T> const&, vnl_vector<T> const&);
template <class T> vnl_matrix<T> outer_product (vnl_vector<T> const&, vnl_vector<T> const&);
template <class T> vnl_vector<T> operator+(T, vnl_vector<T> const&);
template <class T> vnl_vector<T> operator-(T, vnl_vector<T> const&);
template <class T> vnl_vector<T> operator*(T, vnl_vector<T> const&);

template <class T> vnl_vector<T> operator*(vnl_vector<T> const&, vnl_matrix<T> const&);
template <class T> vnl_vector<T> element_product(vnl_vector<T> const&,vnl_vector<T> const&);
template <class T> vnl_vector<T> element_quotient(vnl_vector<T> const&,vnl_vector<T> const&);
template <class T> T cross_2d (vnl_vector<T> const&, vnl_vector<T> const&);
template <class T> vnl_vector<T> cross_3d (vnl_vector<T> const&, vnl_vector<T> const&);
template <class T> T vnl_vector_ssd(vnl_vector<T> const&, vnl_vector<T> const&);
template <class T> void swap(vnl_vector<T> &, vnl_vector<T> &);
#undef v
#undef m
# 70 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h"
template<class T>
class vnl_vector
{
 public:
  friend class vnl_matrix<T>;


  vnl_vector () : num_elmts(0) , data(0) {}



  explicit vnl_vector (unsigned len);


  vnl_vector (unsigned len, T const& v0);


  vnl_vector (unsigned len, int n, T const values[]);




  vnl_vector (unsigned len, T const& px, T const& py);




  vnl_vector (unsigned len, T const& px, T const& py, T const& pz);




  vnl_vector (unsigned len, T const& px, T const& py, T const& pz, T const& pw);


  vnl_vector (T const* data_block,unsigned int n);


  vnl_vector (vnl_vector<T> const&);





  vnl_vector (vnl_vector<T> const &, vnl_vector<T> const &, vnl_tag_add);
  vnl_vector (vnl_vector<T> const &, vnl_vector<T> const &, vnl_tag_sub);
  vnl_vector (vnl_vector<T> const &, T, vnl_tag_mul);
  vnl_vector (vnl_vector<T> const &, T, vnl_tag_div);
  vnl_vector (vnl_vector<T> const &, T, vnl_tag_add);
  vnl_vector (vnl_vector<T> const &, T, vnl_tag_sub);
  vnl_vector (vnl_matrix<T> const &, vnl_vector<T> const &, vnl_tag_mul);
  vnl_vector (vnl_vector<T> const &, vnl_matrix<T> const &, vnl_tag_mul);
  vnl_vector (vnl_vector<T> &that, vnl_tag_grab)
    : num_elmts(that.num_elmts), data(that.data)
  { that.num_elmts=0; that.data=0; }




  ~vnl_vector();


  unsigned size() const { return num_elmts; }


  inline void put (unsigned int i, T const&);


  inline T get (unsigned int i) const;


  void fill (T const& v);



  void copy_in(T const * ptr);



  void copy_out(T *) const;




  void set (T const *ptr) { copy_in(ptr); }



  T & operator() (unsigned int i)
  {

    (static_cast<void> (__builtin_expect (!!(i<size()), 1) ? 0 : (__assert_fail ("i<size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h", 161, __PRETTY_FUNCTION__), 0)));

    return data[i];
  }


  T const & operator() (unsigned int i) const
  {

    (static_cast<void> (__builtin_expect (!!(i<size()), 1) ? 0 : (__assert_fail ("i<size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h", 170, __PRETTY_FUNCTION__), 0)));

    return data[i];
  }


  T & operator[] (unsigned int i) { return data[i]; }

  T const & operator[] (unsigned int i) const { return data[i]; }


  vnl_vector<T>& operator= (T const&v) { fill(v); return *this; }


  vnl_vector<T>& operator= (vnl_vector<T> const& rhs);


  vnl_vector<T>& operator+= (T );


  vnl_vector<T>& operator-= (T value) { return *this += (-value); }


  vnl_vector<T>& operator*= (T );


  vnl_vector<T>& operator/= (T );


  vnl_vector<T>& operator+= (vnl_vector<T> const& rhs);


  vnl_vector<T>& operator-= (vnl_vector<T> const& rhs);



  vnl_vector<T>& pre_multiply (vnl_matrix<T> const& M);



  vnl_vector<T>& post_multiply (vnl_matrix<T> const& M);



  vnl_vector<T>& operator*= (vnl_matrix<T> const& m) { return this->post_multiply(m); }



  vnl_vector<T> operator+ () const { return *this; }



  vnl_vector<T> operator- () const;

  vnl_vector<T> operator+ (T v) const { return vnl_vector<T>(*this, v, vnl_tag_add()); }
  vnl_vector<T> operator- (T v) const { return vnl_vector<T>(*this, v, vnl_tag_sub()); }
  vnl_vector<T> operator* (T v) const { return vnl_vector<T>(*this, v, vnl_tag_mul()); }
  vnl_vector<T> operator/ (T v) const { return vnl_vector<T>(*this, v, vnl_tag_div()); }

  vnl_vector<T> operator+ (vnl_vector<T> const& v) const { return vnl_vector<T>(*this, v, vnl_tag_add()); }
  vnl_vector<T> operator- (vnl_vector<T> const& v) const { return vnl_vector<T>(*this, v, vnl_tag_sub()); }
  vnl_vector<T> operator* (vnl_matrix<T> const& M) const { return vnl_vector<T>(*this, M, vnl_tag_mul()); }





  T const* data_block () const { return data; }



  T * data_block () { return data; }


  typedef T element_type;

  typedef T *iterator;

  iterator begin() { return data; }


  iterator end() { return data+num_elmts; }


  typedef T const *const_iterator;

  const_iterator begin() const { return data; }

  const_iterator end() const { return data+num_elmts; }





  vnl_vector<T> const& as_ref() const { return *this; }


  vnl_vector<T>& as_ref() { return *this; }


  vnl_vector<T> apply(T (*f)(T)) const;

  vnl_vector<T> apply(T (*f)(T const&)) const;


  vnl_vector<T> extract (unsigned int len, unsigned int start=0) const;


  vnl_vector<T>& update (vnl_vector<T> const&, unsigned int start=0);


  typedef typename vnl_c_vector<T>::abs_t abs_t;


  abs_t squared_magnitude() const { return vnl_c_vector<T>::two_nrm2(begin(), size()); }


  abs_t magnitude() const { return two_norm(); }


  abs_t one_norm() const { return vnl_c_vector<T>::one_norm(begin(), size()); }


  abs_t two_norm() const { return vnl_c_vector<T>::two_norm(begin(), size()); }


  abs_t inf_norm() const { return vnl_c_vector<T>::inf_norm(begin(), size()); }


  vnl_vector<T>& normalize() { vnl_c_vector<T>::normalize(begin(), size()); return *this; }





  abs_t rms () const { return vnl_c_vector<T>::rms_norm(begin(), size()); }


  T min_value () const { return vnl_c_vector<T>::min_value(begin(), size()); }


  T max_value () const { return vnl_c_vector<T>::max_value(begin(), size()); }


  T mean() const { return vnl_c_vector<T>::mean(begin(), size()); }


  T sum() const { return vnl_c_vector<T>::sum(begin(), size()); }



  void flip();


  void swap(vnl_vector<T> & that);


  T& x() const { return data[0]; }

  T& y() const { return data[1]; }

  T& z() const { return data[2]; }

  T& t() const { return data[3]; }
# 348 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h"
  void assert_size(unsigned sz) const {

    assert_size_internal(sz);

  }



  void assert_finite() const {

    assert_finite_internal();

  }


  bool is_finite() const;


  bool is_zero() const;


  bool empty() const { return !data || !num_elmts; }


  bool operator_eq (vnl_vector<T> const& v) const;


  bool operator==(vnl_vector<T> const &that) const { return this->operator_eq(that); }


  bool operator!=(vnl_vector<T> const &that) const { return !this->operator_eq(that); }




  bool set_size (unsigned n);


  void clear();



  bool read_ascii(std :: istream& s);


  static vnl_vector<T> read(std :: istream& s);


 protected:
  unsigned num_elmts;
  T* data;







  void assert_size_internal(unsigned sz) const;
  void assert_finite_internal() const;

  void destroy();
# 435 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h"
  static void inline_function_tickler();
};
# 445 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector.h"
template <class T>
inline T vnl_vector<T>::get (unsigned int index) const {




  return this->data[index];
}




template <class T>
inline void vnl_vector<T>::put (unsigned int index, T const& value) {




  this->data[index] = value;
}




template<class T>
inline vnl_vector<T> operator* (vnl_matrix<T> const& m, vnl_vector<T> const& v) {
  return vnl_vector<T>(m, v, vnl_tag_mul());
}



template<class T>
inline vnl_vector<T> operator+ (T s, vnl_vector<T> const& v) {
  return vnl_vector<T>(v, s, vnl_tag_add());
}



template<class T>
inline vnl_vector<T> operator- (T s, vnl_vector<T> const& v) {
  return vnl_vector<T>(-v, s, vnl_tag_add());
}



template<class T>
inline vnl_vector<T> operator* (T s, vnl_vector<T> const& v) {
  return vnl_vector<T>(v, s, vnl_tag_mul());
}



template<class T>
inline void swap(vnl_vector<T> &a, vnl_vector<T> &b) { a.swap(b); }




template<class T>
inline T vnl_vector_ssd (vnl_vector<T> const& v1, vnl_vector<T> const& v2)
{

  if (v1.size() != v2.size())
    vnl_error_vector_dimension ("vnl_vector_ssd", v1.size(), v2.size());

  return vnl_c_vector<T>::euclid_dist_sq(v1.begin(), v2.begin(), v1.size());
}





 template <class T> std :: ostream& operator<< (std :: ostream &, vnl_vector<T> const&);


 template <class T> std :: istream& operator>> (std :: istream &, vnl_vector<T> &);
# 21 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_ref.h" 2




 template <class T>
class vnl_vector_ref : public vnl_vector<T>
{
 public:
  typedef vnl_vector<T> Base;



  vnl_vector_ref(unsigned n, T *space) : vnl_vector<T>() {
    Base::data = space;
    Base::num_elmts = n;



  }




  vnl_vector_ref(vnl_vector_ref<T> const& v) : vnl_vector<T>() {
    Base::data = const_cast<T*>(v.data_block());
    Base::num_elmts = v.size();



  }



  ~vnl_vector_ref() {
    Base::data = 0;
  }
# 72 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_ref.h"
  vnl_vector_ref& non_const() { return *this; }

 private:


  vnl_vector_ref(vnl_vector<T> const&) {}
# 91 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_ref.h"
};
# 23 "/tmp/installed/include/InsightToolkit/Common/itkVector.h" 2


namespace itk
{
# 56 "/tmp/installed/include/InsightToolkit/Common/itkVector.h"
template<class T, unsigned int NVectorDimension=3>
class Vector : public FixedArray<T,NVectorDimension>
{
public:

  typedef Vector Self;
  typedef FixedArray<T,NVectorDimension> Superclass;



  typedef T ValueType;
  typedef typename NumericTraits< ValueType >::RealType RealValueType;


  static const unsigned int Dimension = NVectorDimension;


  typedef Self VectorType;


  typedef T ComponentType;


  typedef FixedArray<T, NVectorDimension> BaseArray;


  static unsigned int GetVectorDimension()
    { return NVectorDimension; }


  void Set_vnl_vector( const vnl_vector<T> & );


  vnl_vector_ref<T> Get_vnl_vector( void );


  vnl_vector<T> Get_vnl_vector( void ) const;


  Vector(): BaseArray() { }
  Vector(const ValueType& r);


  Vector(const Self& r): BaseArray(r) {}
  Vector(const ValueType r[Dimension]): BaseArray(r) {}


  Vector& operator= (const Self& r);
  Vector& operator= (const ValueType r[Dimension]);


  const Self& operator*=(const ValueType &value);


  const Self& operator/=(const ValueType &value);


  const Self& operator+=(const Self &vec);


  const Self& operator-=(const Self &vec);



  Self operator-() const;


  Self operator+(const Self &vec) const;


  Self operator-(const Self &vec) const;



  ValueType operator*(const Self &vec) const;



  Self operator*(const ValueType& val) const;



  Self operator/(const ValueType& val) const;





  bool operator==(const Self& v) const
    { return Superclass::operator==(v); }
  bool operator!=(const Self& v) const
    { return !operator==(v); }


  RealValueType GetNorm( void ) const;


  RealValueType GetSquaredNorm( void ) const;


  static int GetNumberOfComponents(){ return NVectorDimension;}


  void Normalize(void);

  void SetNthComponent(int c, const ComponentType& v)
    { this->operator[](c) = v; }



  template < typename TCoordRepB >
  void CastFrom( const Vector<TCoordRepB,NVectorDimension> & pa )
  {
    if (false) { } else for(unsigned int i=0; i<NVectorDimension; i++ )
      {
      (*this)[i] = static_cast<T>( pa[i] );
      }
  }

};

template< class T, unsigned int NVectorDimension >
 std::ostream& operator<<(std::ostream& os,
                                    const Vector<T,NVectorDimension> & v);

template< class T, unsigned int NVectorDimension >
 std::istream& operator>>(std::istream& is,
                                    Vector<T,NVectorDimension> & v);

 Vector<double,3> CrossProduct( const Vector<double,3> &,
                                          const Vector<double,3> & );

 Vector<float,3> CrossProduct( const Vector<float,3> &,
                                         const Vector<float,3> & );

 Vector<int,3> CrossProduct( const Vector<int,3> &,
                                       const Vector<int,3> & );

}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkVector.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkVector.txx"
#define _itkVector_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkVector.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkVector.txx" 2

# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_math.h" 1


#define vnl_math_h_ 
# 39 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_math.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/dll.h" 1


#define vnl_dll_h_ 



#define VNL_DLL_DATA 
# 40 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_math.h" 2


template <class T> T vnl_huge_val(T);
double vnl_huge_val(double);
float vnl_huge_val(float);
long int vnl_huge_val(long int);
int vnl_huge_val(int);
short vnl_huge_val(short);
char vnl_huge_val(char);


class vnl_math
{
 public:

  static const double e = 2.7182818284590452354;
  static const double log2e = 1.4426950408889634074;
  static const double log10e = 0.43429448190325182765;
  static const double ln2 = 0.69314718055994530942;
  static const double ln10 = 2.30258509299404568402;
  static const double pi = 3.14159265358979323846;
  static const double pi_over_2 = 1.57079632679489661923;
  static const double pi_over_4 = 0.78539816339744830962;
  static const double one_over_pi = 0.31830988618379067154;
  static const double two_over_pi = 0.63661977236758134308;
  static const double two_over_sqrtpi = 1.12837916709551257390;
  static const double sqrt2 = 1.41421356237309504880;
  static const double sqrt1_2 = 0.70710678118654752440;


  static const double eps = 2.2204460492503131e-16;
  static const double sqrteps = 1.490116119384766e-08;

  static const float float_eps = 1.192092896e-07f;
  static const float float_sqrteps = 3.4526698307e-4f;
# 84 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_math.h"
};
# 101 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_math.h"
inline bool vnl_math_isnan(char) { return false; }
inline bool vnl_math_isnan(short) { return false; }
inline bool vnl_math_isnan(int) { return false; }
inline bool vnl_math_isnan(long) { return false; }
inline bool vnl_math_isnan(signed char) { return false; }
inline bool vnl_math_isnan(unsigned char) { return false; }
inline bool vnl_math_isnan(unsigned short) { return false; }
inline bool vnl_math_isnan(unsigned int) { return false; }
inline bool vnl_math_isnan(unsigned long) { return false; }
bool vnl_math_isnan(float);
bool vnl_math_isnan(double);
bool vnl_math_isnan(long double);

template <class T> bool vnl_math_isnan(T);



inline bool vnl_math_isinf(char) { return false; }
inline bool vnl_math_isinf(short) { return false; }
inline bool vnl_math_isinf(int) { return false; }
inline bool vnl_math_isinf(long) { return false; }
inline bool vnl_math_isinf(signed char) { return false; }
inline bool vnl_math_isinf(unsigned char) { return false; }
inline bool vnl_math_isinf(unsigned short) { return false; }
inline bool vnl_math_isinf(unsigned int) { return false; }
inline bool vnl_math_isinf(unsigned long) { return false; }
bool vnl_math_isinf(float);
bool vnl_math_isinf(double);
bool vnl_math_isinf(long double);

template <class T> bool vnl_math_isinf(T);



inline bool vnl_math_isfinite(char) { return true; }
inline bool vnl_math_isfinite(short) { return true; }
inline bool vnl_math_isfinite(int) { return true; }
inline bool vnl_math_isfinite(long) { return true; }
inline bool vnl_math_isfinite(signed char) { return true; }
inline bool vnl_math_isfinite(unsigned char) { return true; }
inline bool vnl_math_isfinite(unsigned short) { return true; }
inline bool vnl_math_isfinite(unsigned int) { return true; }
inline bool vnl_math_isfinite(unsigned long) { return true; }
bool vnl_math_isfinite(float);
bool vnl_math_isfinite(double);
bool vnl_math_isfinite(long double);

template <class T> bool vnl_math_isfinite(T);



inline int vnl_math_rnd(float x) { return (x>=0.0)?(int)(x + 0.5):(int)(x - 0.5); }
inline int vnl_math_rnd(double x) { return (x>=0.0)?(int)(x + 0.5):(int)(x - 0.5); }


inline bool vnl_math_abs(bool x) { return x; }
inline unsigned char vnl_math_abs(unsigned char x) { return x; }
inline unsigned char vnl_math_abs(signed char x) { return x < 0 ? -x : x; }
inline unsigned char vnl_math_abs(char x) { return (unsigned char)x; }
inline unsigned short vnl_math_abs(short x) { return x < 0 ? -x : x; }
inline unsigned short vnl_math_abs(unsigned short x) { return x; }
inline int vnl_math_abs(int x) { return x < 0 ? -x : x; }
inline unsigned int vnl_math_abs(unsigned int x) { return x; }
inline long vnl_math_abs(long x) { return x < 0 ? -x : x; }
inline unsigned long vnl_math_abs(unsigned long x) { return x; }
inline float vnl_math_abs(float x) { return x < 0.0f ? -x : x; }
inline double vnl_math_abs(double x) { return x < 0.0 ? -x : x; }
inline long double vnl_math_abs(long double x) { return x < 0.0 ? -x : x; }


inline int vnl_math_max(int x, int y) { return (x > y) ? x : y; }
inline unsigned int vnl_math_max(unsigned int x, unsigned int y) { return (x > y) ? x : y; }
inline long vnl_math_max(long x, long y) { return (x > y) ? x : y; }
inline unsigned long vnl_math_max(unsigned long x, unsigned long y) { return (x > y) ? x : y;}
inline float vnl_math_max(float x, float y) { return (x < y) ? y : x; }
inline double vnl_math_max(double x, double y) { return (x < y) ? y : x; }


inline int vnl_math_min(int x, int y) { return (x < y) ? x : y; }
inline unsigned int vnl_math_min(unsigned int x, unsigned int y) { return (x < y) ? x : y; }
inline long vnl_math_min(long x, long y) { return (x < y) ? x : y; }
inline unsigned long vnl_math_min(unsigned long x, unsigned long y) { return (x < y) ? x : y;}
inline float vnl_math_min(float x, float y) { return (x > y) ? y : x; }
inline double vnl_math_min(double x, double y) { return (x > y) ? y : x; }


inline bool vnl_math_sqr(bool x) { return x; }
inline int vnl_math_sqr(int x) { return x*x; }
inline unsigned int vnl_math_sqr(unsigned int x) { return x*x; }
inline long vnl_math_sqr(long x) { return x*x; }
inline float vnl_math_sqr(float x) { return x*x; }
inline double vnl_math_sqr(double x) { return x*x; }


inline int vnl_math_sgn(int x) { return x?((x>0)?1:-1):0; }
inline int vnl_math_sgn(long x) { return x?((x>0)?1:-1):0; }
inline int vnl_math_sgn(float x) { return (x != 0)?((x>0)?1:-1):0; }
inline int vnl_math_sgn(double x) { return (x != 0)?((x>0)?1:-1):0; }


inline int vnl_math_sgn0(int x) { return (x>=0)?1:-1; }
inline int vnl_math_sgn0(long x) { return (x>=0)?1:-1; }
inline int vnl_math_sgn0(float x) { return (x>=0)?1:-1; }
inline int vnl_math_sgn0(double x) { return (x>=0)?1:-1; }


inline unsigned int vnl_math_squared_magnitude(char x) { return int(x)*int(x); }
inline unsigned int vnl_math_squared_magnitude(unsigned char x) { return int(x)*int(x); }
inline unsigned int vnl_math_squared_magnitude(int x) { return x*x; }
inline unsigned int vnl_math_squared_magnitude(unsigned int x) { return x*x; }
inline long vnl_math_squared_magnitude(long x) { return x*x; }
inline unsigned long vnl_math_squared_magnitude(unsigned long x) { return x*x; }
inline float vnl_math_squared_magnitude(float x) { return x*x; }
inline double vnl_math_squared_magnitude(double x) { return x*x; }
inline long double vnl_math_squared_magnitude(long double x) { return x*x; }


inline float vnl_math_cuberoot(float a) { return float((a<0) ? -std :: exp(std :: log(-a)/3) : std :: exp(std :: log(a)/3)); }
inline double vnl_math_cuberoot(double a) { return (a<0) ? -std :: exp(std :: log(-a)/3) : std :: exp(std :: log(a)/3); }


inline double vnl_math_hypot(int x, int y) { return std :: sqrt(double(x*x + y*y)); }
inline float vnl_math_hypot(float x, float y) { return float( std :: sqrt(double(x*x + y*y)) ); }
inline double vnl_math_hypot(double x, double y) { return std :: sqrt(x*x + y*y); }
inline long double vnl_math_hypot(long double x, long double y) { return std :: sqrt(x*x + y*y); }
# 23 "/tmp/installed/include/InsightToolkit/Common/itkVector.txx" 2



namespace itk
{





template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>
::Vector(const ValueType& r)
{
  if (false) { } else for(typename BaseArray::Iterator i = BaseArray::Begin(); i != BaseArray::End(); ++i)
    {
    *i = r;
    }
}


template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>&
Vector<T, TVectorDimension>
::operator= (const Self& r)
{
  BaseArray::operator=(r);
  return *this;
}


template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>&
Vector<T, TVectorDimension>
::operator= (const ValueType r[Dimension])
{
  BaseArray::operator=(r);
  return *this;
}





template<class T, unsigned int TVectorDimension>
const Vector<T, TVectorDimension> &
Vector<T, TVectorDimension>
::operator*=( const ValueType & value )
{
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    (*this)[i] *= value;
    }
  return *this;
}





template<class T, unsigned int TVectorDimension>
const Vector<T, TVectorDimension> &
Vector<T, TVectorDimension>
::operator/=( const ValueType & value )
{
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    (*this)[i] /= value;
    }
  return *this;
}





template<class T, unsigned int TVectorDimension>
const typename Vector<T, TVectorDimension>::Self &
Vector<T, TVectorDimension>
::operator+=( const Self & vec )
{
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    (*this)[i] += vec[i];
    }
  return *this;
}





template<class T, unsigned int TVectorDimension>
const typename Vector<T, TVectorDimension>::Self &
Vector<T, TVectorDimension>
::operator-=( const Self & vec )
{
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    (*this)[i] -= vec[i];
    }
  return *this;
}





template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>
Vector<T, TVectorDimension>
::operator-() const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    result[i] = -(*this)[i];
    }
  return result;
}






template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>
Vector<T, TVectorDimension>
::operator+( const Self & vec ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    result[i] = (*this)[i] + vec[i];
    }
  return result;
}






template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>
Vector<T, TVectorDimension>
::operator-( const Self & vec ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    result[i] = (*this)[i] - vec[i];
    }
  return result;
}






template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>
Vector<T, TVectorDimension>
::operator*( const ValueType & value ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    result[i] = (*this)[i] * value;
    }
  return result;
}





template<class T, unsigned int TVectorDimension>
typename Vector<T, TVectorDimension>::RealValueType
Vector<T, TVectorDimension>
::GetSquaredNorm( void ) const
{
  typename NumericTraits<RealValueType>::AccumulateType sum = NumericTraits<T>::Zero;
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    const RealValueType value = (*this)[i];
    sum += value * value;
    }
  return sum;
}






template<class T, unsigned int TVectorDimension>
typename Vector<T, TVectorDimension>::RealValueType
Vector<T, TVectorDimension>
::GetNorm( void ) const
{
  return RealValueType( sqrt( double(this->GetSquaredNorm()) ));
}





template<class T, unsigned int TVectorDimension>
void
Vector<T, TVectorDimension>
::Normalize( void )
{
  const RealValueType norm = this->GetNorm();
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    (*this)[i] /= norm;
    }
}







template<class T, unsigned int TVectorDimension>
Vector<T, TVectorDimension>
Vector<T, TVectorDimension>
::operator/( const ValueType & value ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    result[i] = (*this)[i] / value;
    }
  return result;
}






template<class T, unsigned int TVectorDimension>
void
Vector<T, TVectorDimension>
::Set_vnl_vector( const vnl_vector<T> & v)
{
  if (false) { } else for(unsigned int i=0;i<v.size();i++)
    {
    (*this)[i] = v(i);
    }
}





template<class T, unsigned int TVectorDimension>
vnl_vector_ref< T >
Vector<T, TVectorDimension>
::Get_vnl_vector( void )
{
  return vnl_vector_ref< T >( TVectorDimension, this->GetDataPointer() );
}





template<class T, unsigned int TVectorDimension>
vnl_vector< T >
Vector<T, TVectorDimension>
::Get_vnl_vector( void ) const
{




  return vnl_vector_ref<T>( TVectorDimension,
                            const_cast<T*>(this->GetDataPointer()));
}





template<class T, unsigned int TVectorDimension>
std::ostream &
operator<<(std::ostream& os,const Vector<T,TVectorDimension> & vct )
{
  os << "[";
  if ( TVectorDimension == 1)
    {
    os << vct[0];
    }
  else
    {
    if (false) { } else for( unsigned int i=0; i+1<TVectorDimension; i++)
      {
      os << vct[i] << ", ";
      }
    os << vct[TVectorDimension-1];
    }
  os << "]";
  return os;
}





template<class T, unsigned int TVectorDimension>
std::istream &
operator>>(std::istream& is, Vector<T,TVectorDimension> & vct )
{
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    is >> vct[i];
    }
  return is;
}





template<class T, unsigned int TVectorDimension>
typename Vector<T, TVectorDimension>::ValueType
Vector<T, TVectorDimension>
::operator*( const Self & other ) const
{
  typename NumericTraits<T>::AccumulateType value = NumericTraits<T>::Zero;
  if (false) { } else for( unsigned int i=0; i<TVectorDimension; i++)
    {
    value += (*this)[i] * other[i];
    }
  return value;
}




}
# 199 "/tmp/installed/include/InsightToolkit/Common/itkVector.h" 2
# 21 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h" 2



namespace itk
{
# 41 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
template<class TCoordRep, unsigned int NPointDimension=3>
class Point : public FixedArray< TCoordRep, NPointDimension >
{
public:

  typedef Point Self;
  typedef FixedArray<TCoordRep,NPointDimension> Superclass;



  typedef TCoordRep ValueType;
  typedef TCoordRep CoordRepType;

  typedef typename NumericTraits< ValueType >::RealType RealType;


  static const unsigned int PointDimension = NPointDimension;


  typedef FixedArray<TCoordRep, NPointDimension> BaseArray;
  typedef typename BaseArray::Iterator Iterator;
  typedef typename BaseArray::ConstIterator ConstIterator;


  static unsigned int GetPointDimension()
    { return NPointDimension; }


  typedef Vector< ValueType, NPointDimension > VectorType;


  Point() {}


  Point(const Self& r): BaseArray(r) {}
  Point(const ValueType r[PointDimension]): BaseArray(r) {}


  Point& operator= (const Self& r);
  Point& operator= (const ValueType r[PointDimension]);


  bool
  operator==(const Self &pt) const
    {
    bool same=true;
    if (false) { } else for (unsigned int i=0; i < PointDimension && same; i++)
      { same = ((*this)[i] == pt[i]); }
    return same;
    }


  bool
  operator!=(const Self &pt) const
    {
    bool same=true;
    if (false) { } else for (unsigned int i=0; i < PointDimension && same; i++)
      { same = ((*this)[i] == pt[i]); }
    return !same;
    }


  const Self& operator+=(const VectorType &vec);


  const Self& operator-=(const VectorType &vec);


  VectorType operator-(const Self &pnt) const;


  Self operator+(const VectorType &vec) const;


  Self operator-(const VectorType &vec) const;


  VectorType GetVectorFromOrigin() const;


  vnl_vector_ref<TCoordRep> Get_vnl_vector( void );


  vnl_vector<TCoordRep> Get_vnl_vector( void ) const;
# 137 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
  void SetToMidPoint( const Self &, const Self & );
# 163 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
  void SetToBarycentricCombination( const Self & A, const Self & B, double alpha );
# 180 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
  void SetToBarycentricCombination( const Self & A, const Self & B, const Self & C,
                                    double weightA, double weightB );
# 195 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
  void SetToBarycentricCombination( const Self * P, const double * weights, unsigned int N);




  template < typename TCoordRepB >
  void CastFrom( const Point<TCoordRepB,NPointDimension> & pa )
  {
    if (false) { } else for(unsigned int i=0; i<NPointDimension; i++ )
      {
      (*this)[i] = static_cast<TCoordRep>( pa[i] );
      }
  }





  template < typename TCoordRepB >
  RealType SquaredEuclideanDistanceTo( const Point<TCoordRepB,NPointDimension> & pa ) const
  {
    RealType sum = NumericTraits< RealType >::Zero;
    if (false) { } else for(unsigned int i=0; i<NPointDimension; i++ )
      {
      const RealType component = static_cast< RealType >( pa[i] );
      const ValueType difference = (*this)[i] - component;
      sum += difference * difference;
      }
  return sum;
  }





  template < typename TCoordRepB >
  RealType EuclideanDistanceTo( const Point<TCoordRepB,NPointDimension> & pa ) const
  {
  const double distance = sqrt(
    static_cast<double>( this->SquaredEuclideanDistanceTo( pa ) ) ) ;
  return static_cast<RealType>( distance );
  }


};

template< class T, unsigned int NPointDimension >
 std::ostream& operator<<(std::ostream& os,
                                    const Point<T,NPointDimension> & v);

template< class T, unsigned int NPointDimension >
 std::istream& operator>>(std::istream& is,
                                    Point<T,NPointDimension> & v);
# 270 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
template< class TPointContainer, class TWeightContainer >
 class BarycentricCombination
{
public:

  typedef TPointContainer PointContainerType;
  typedef typename PointContainerType::Pointer PointContainerPointer;
  typedef typename PointContainerType::Element PointType;
  typedef TWeightContainer WeightContainerType;

  BarycentricCombination() {};
  ~BarycentricCombination() {};

  static PointType Evaluate(
    const PointContainerPointer & points,
    const WeightContainerType & weights );
};
# 295 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h"
}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkPoint.txx" 1
# 19 "/tmp/installed/include/InsightToolkit/Common/itkPoint.txx"
#define _itkPoint_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkPoint.txx" 2




namespace itk
{





template<class T, unsigned int TPointDimension>
Point<T, TPointDimension>&
Point<T, TPointDimension>
::operator= (const Self& r)
{
  BaseArray::operator=(r);
  return *this;
}





template<class T, unsigned int TPointDimension>
Point<T, TPointDimension>&
Point<T, TPointDimension>
::operator= (const ValueType r[PointDimension])
{
  BaseArray::operator=(r);
  return *this;
}





template<class T, unsigned int TPointDimension>
const Point<T, TPointDimension> &
Point<T, TPointDimension>
::operator+=( const VectorType & vec )
{
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    (*this)[i] += vec[i];
    }
  return *this;
}





template<class T, unsigned int TPointDimension>
const Point<T, TPointDimension> &
Point<T, TPointDimension>
::operator-=( const VectorType & vec )
{
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    (*this)[i] -= vec[i];
    }
  return *this;
}






template<class T, unsigned int TPointDimension>
Point<T, TPointDimension>
Point<T, TPointDimension>
::operator+( const VectorType & vec ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    result[i] = (*this)[i] + vec[i];
    }
  return result;
}






template<class T, unsigned int TPointDimension>
Point<T, TPointDimension>
Point<T, TPointDimension>
::operator-( const VectorType & vec ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    result[i] = (*this)[i] - vec[i];
    }
  return result;
}






template<class T, unsigned int TPointDimension>
Vector<T, TPointDimension>
Point<T, TPointDimension>
::operator-( const Self & pnt ) const
{
  VectorType result;
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    result[i] = (*this)[i] - pnt[i];
    }
  return result;
}





template<class T, unsigned int TPointDimension >
vnl_vector_ref< T >
Point<T, TPointDimension>
::Get_vnl_vector( void )
{
  return vnl_vector_ref< T >( TPointDimension, this->GetDataPointer());
}




template<class T, unsigned int TPointDimension>
vnl_vector< T >
Point<T, TPointDimension>
::Get_vnl_vector( void ) const
{




  return vnl_vector_ref<T>( TPointDimension,
                            const_cast<T*>(this->GetDataPointer()));
}

template<class T, unsigned int TPointDimension >
typename Point<T, TPointDimension>::VectorType
Point<T, TPointDimension>
::GetVectorFromOrigin() const
{

  return &(*this)[0];
}






template<class T, unsigned int TPointDimension>
void
Point<T, TPointDimension>
::SetToMidPoint( const Self & A, const Self & B )
{
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    (*this)[i] = ( A[i] + B[i] ) /2.0;
    }
}
# 200 "/tmp/installed/include/InsightToolkit/Common/itkPoint.txx"
template<class T, unsigned int TPointDimension>
void
Point<T, TPointDimension>
::SetToBarycentricCombination( const Self & A,
                               const Self & B,
                               double alpha )
{
  const double wa = alpha;
  const double wb = 1.0 - alpha;
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    (*this)[i] = wa * A[i] + wb * B[i];
    }
}






template<class T, unsigned int TPointDimension>
void
Point<T, TPointDimension>
::SetToBarycentricCombination( const Self & A,
                               const Self & B,
                               const Self & C,
                               double weightForA,
                               double weightForB )
{
  const double weightForC = 1.0 - weightForA - weightForB;
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    (*this)[i] = weightForA * A[i] + weightForB * B[i] + weightForC * C[i];
    }
}






template<class T, unsigned int TPointDimension>
void
Point<T, TPointDimension>
::SetToBarycentricCombination( const Self * P,
                               const double * weights, unsigned int N )
{
  Fill( NumericTraits<T>::Zero );
  double weightSum = 0.0;
  if (false) { } else for( unsigned int j=0; j<N-1; j++)
    {
    const double weight = weights[j];
    weightSum += weight;
    if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
      {
      (*this)[i] += weight * P[j][i];
      }
    }
  const double weight = ( 1.0 - weightSum );
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    (*this)[i] += weight * P[N-1][i];
    }

}







template< class TPointContainer, class TWeightContainer >
typename BarycentricCombination<TPointContainer,TWeightContainer>
::PointType
BarycentricCombination<TPointContainer,TWeightContainer>
::Evaluate(
  const PointContainerPointer & points,
  const WeightContainerType & weights )
{

  typedef typename TPointContainer::Element PointType;
  typedef typename PointType::ValueType ValueType;
  PointType barycentre;
  barycentre.Fill( NumericTraits< ValueType >::Zero );

  typename TPointContainer::Iterator point = points->Begin();
  typename TPointContainer::Iterator final = points->End();
  typename TPointContainer::Iterator last = final;
  last--;

  double weightSum = 0.0;

  const unsigned int PointDimension = PointType::PointDimension;
  unsigned int j = 0;

  while( point != last )
    {
    const double weight = weights[j++];
    weightSum += weight;
    if (false) { } else for( unsigned int i=0; i<PointDimension; i++)
      {
      barycentre[i] += weight * (point->Value())[i];
      }
    point++;
    }



  const double weight = ( 1.0 - weightSum );
  if (false) { } else for( unsigned int i=0; i<PointDimension; i++)
    {
    barycentre[i] += weight * (last->Value())[i];
    }

  return barycentre;

}
# 326 "/tmp/installed/include/InsightToolkit/Common/itkPoint.txx"
template<class T, unsigned int TPointDimension>
std::ostream &
operator<<(std::ostream& os,const Point<T,TPointDimension> & vct )
{
  os << "[";
  if ( TPointDimension == 1)
    {
    os << vct[0];
    }
  else
    {
    if (false) { } else for( unsigned int i=0; i+1<TPointDimension; i++)
      {
      os << vct[i] << ", ";
      }
    os << vct[TPointDimension-1];
    }
  os << "]";
  return os;
}






template<class T, unsigned int TPointDimension>
std::istream &
operator>>(std::istream& is, Point<T,TPointDimension> & vct )
{
  if (false) { } else for( unsigned int i=0; i<TPointDimension; i++)
    {
    is >> vct[i];
    }
  return is;
}



}
# 299 "/tmp/installed/include/InsightToolkit/Common/itkPoint.h" 2
# 30 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.h"
#define __itkImageRegion_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkRegion.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkRegion.h"
#define __itkRegion_h 



namespace itk
{
# 56 "/tmp/installed/include/InsightToolkit/Common/itkRegion.h"
class Region
{
public:

  typedef Region Self;


  enum RegionType {ITK_UNSTRUCTURED_REGION,ITK_STRUCTURED_REGION};


  virtual const char *GetNameOfClass() const {return "Region";};



  virtual RegionType GetRegionType() const = 0;


  virtual void Print(std::ostream& os, Indent indent=0) const;

protected:




  virtual void PrintSelf(std::ostream& os, Indent indent) const;
  virtual void PrintHeader(std::ostream& os, Indent indent) const;
  virtual void PrintTrailer(std::ostream& os, Indent indent) const;

private:

};

}
# 24 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.h" 2



# 1 "/tmp/installed/include/InsightToolkit/Common/itkContinuousIndex.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkContinuousIndex.h"
#define __itkContinuousIndex_h 




namespace itk
{
# 44 "/tmp/installed/include/InsightToolkit/Common/itkContinuousIndex.h"
template<class TCoordRep = double, unsigned int VIndexDimension=2>
class ContinuousIndex : public Point< TCoordRep, VIndexDimension >
{
public:

  typedef ContinuousIndex Self;
  typedef Point<TCoordRep,VIndexDimension> Superclass;



  typedef TCoordRep ValueType;
  typedef TCoordRep CoordRepType;


  static const unsigned int IndexDimension = VIndexDimension;


  typedef Index<VIndexDimension> IndexType;


  typedef typename Superclass::BaseArray BaseArray;
  typedef typename BaseArray::Iterator Iterator;
  typedef typename BaseArray::ConstIterator ConstIterator;


  ContinuousIndex() {}


  ContinuousIndex(const Self& r): Superclass(r) {}

  ContinuousIndex(const ValueType r[IndexDimension]): Superclass(r) {}


  ContinuousIndex(const IndexType& index )
    {
    if (false) { } else for( unsigned int i = 0; i < VIndexDimension; i++ )
      {
      (*this)[i] = TCoordRep( index[i] );
      }
    }
};



}
# 28 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.h" 2

namespace itk
{


template <unsigned int VImageDimension> class ImageBase;
# 53 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.h"
template <unsigned int VImageDimension>
class ImageRegion: public Region
{
public:

  typedef ImageRegion Self;
  typedef Region Superclass;


  virtual const char *GetNameOfClass() const {return "ImageRegion";};


  static const unsigned int ImageDimension = VImageDimension;



  static const unsigned int SliceDimension = (VImageDimension - (VImageDimension > 1));



  static unsigned int GetImageDimension()
    { return VImageDimension; }


  typedef Index<VImageDimension> IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;


  typedef Size<VImageDimension> SizeType;
  typedef typename SizeType::SizeValueType SizeValueType;


  typedef ImageRegion<(Self::SliceDimension)> SliceRegion;


  virtual typename Superclass::RegionType GetRegionType() const
    {return Superclass::ITK_STRUCTURED_REGION;}



  ImageRegion();



  virtual ~ImageRegion();



  ImageRegion(const Self& region): Region(region), m_Index( region.m_Index ), m_Size( region.m_Size ) {}



  ImageRegion(const IndexType &index, const SizeType &size)
    { m_Index = index; m_Size = size; };




  ImageRegion(const SizeType &size)
    { m_Size = size; m_Index.Fill(0); } ;



  void operator=(const Self& region)
    { m_Index = region.m_Index; m_Size = region.m_Size; };


  void SetIndex(const IndexType &index)
    { m_Index = index; };


  const IndexType& GetIndex() const
    { return m_Index; };



  void SetSize(const SizeType &size)
    { m_Size = size; };


  const SizeType& GetSize() const
    { return m_Size; }


  void SetSize(unsigned long i, SizeValueType sze)
    { m_Size[i] = sze; }
  SizeValueType GetSize(unsigned long i) const
    { return m_Size[i]; }


  void SetIndex(unsigned long i, IndexValueType sze)
    { m_Index[i] = sze; }
  IndexValueType GetIndex(unsigned long i) const
    { return m_Index[i]; }


  bool
  operator==(const Self &region) const
    {
      bool same = 1;
      same = (m_Index == region.m_Index);
      same = same && (m_Size == region.m_Size);
      return same;
    }


  bool
  operator!=(const Self &region) const
    {
      bool same = 1;
      same = (m_Index == region.m_Index);
      same = same && (m_Size == region.m_Size);
      return !same;
    }



  bool
  IsInside(const IndexType &index) const
    {
      if (false) { } else for(unsigned int i=0; i<ImageDimension; i++)
        {
        if( index[i] < m_Index[i] )
          {
          return false;
          }
        if( index[i] >= m_Index[i] + static_cast<long>(m_Size[i]) )
          {
          return false;
          }
        }
      return true;
    }


  template <typename TCoordRepType>
  bool
  IsInside(const ContinuousIndex<TCoordRepType,VImageDimension> &index) const
    {
      if (false) { } else for(unsigned int i=0; i<ImageDimension; i++)
        {
        if( index[i] < static_cast<TCoordRepType>( m_Index[i] ) )
          {
          return false;
          }

        const TCoordRepType bound = static_cast<TCoordRepType>(
                              m_Index[i] + static_cast<long>(m_Size[i]) - 1);

        if( index[i] > bound )
          {
          return false;
          }
        }
      return true;
    }



  bool
  IsInside(const Self &region) const
    {
      IndexType beginCorner = region.GetIndex();
      if( ! this->IsInside( beginCorner ) )
        {
        return false;
        }
      IndexType endCorner;
      SizeType size = region.GetSize();
      if (false) { } else for(unsigned int i=0; i<ImageDimension; i++)
        {
        endCorner[i] = beginCorner[i] + size[i] - 1;
        }
      if( ! this->IsInside( endCorner ) )
        {
        return false;
        }
      return true;
    }



  unsigned long GetNumberOfPixels() const;




  void PadByRadius(unsigned long radius);
  void PadByRadius(const unsigned long radius[VImageDimension]);
  void PadByRadius(const SizeType &radius);





  bool Crop(const Self& region);




  SliceRegion Slice(const unsigned long dim) const;

protected:




  virtual void PrintSelf(std::ostream& os, Indent indent) const;

private:
  IndexType m_Index;
  SizeType m_Size;


  friend class ImageBase<VImageDimension>;
};


template<unsigned int VImageDimension>
std::ostream & operator<<(std::ostream &os, const ImageRegion<VImageDimension> &region)
{
  region.Print(os);
  return os;
}

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.txx" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.txx"
#define _itkImageRegion_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.h" 1
# 23 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.txx" 2

namespace itk
{




template<unsigned int VImageDimension>
ImageRegion<VImageDimension>
::ImageRegion()
{
  m_Index.Fill(0);
  m_Size.Fill(0);
}




template<unsigned int VImageDimension>
ImageRegion<VImageDimension>
::~ImageRegion()
{
}

template<unsigned int VImageDimension>
unsigned long
ImageRegion<VImageDimension>
::GetNumberOfPixels() const
{
  unsigned long numPixels=1;

  if (false) { } else for (unsigned int i=0; i<VImageDimension; i++)
    {
    numPixels *= m_Size[i];
    }

  return numPixels;
}

template<unsigned int VImageDimension>
void
ImageRegion<VImageDimension>
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os, indent);

  os << indent << "Dimension: " << this->GetImageDimension() << std::endl;
  os << indent << "Index: " << this->GetIndex() << std::endl;
  os << indent << "Size: " << this->GetSize() << std::endl;
}


template<unsigned int VImageDimension>
void
ImageRegion<VImageDimension>
::PadByRadius(unsigned long radius)
{
  unsigned long radiusVector[VImageDimension];

  if (false) { } else for (unsigned int i=0; i < VImageDimension; ++i)
    {
    radiusVector[i] = radius;
    }

  this->PadByRadius(radiusVector);
}

template<unsigned int VImageDimension>
void
ImageRegion<VImageDimension>
::PadByRadius(const SizeType &radius)
{
  this->PadByRadius( radius.GetSize() );
}

template<unsigned int VImageDimension>
void
ImageRegion<VImageDimension>
::PadByRadius(const unsigned long radius[VImageDimension])
{
  if (false) { } else for (unsigned int i = 0; i < VImageDimension; i++)
    {
    m_Size[i] += 2 * radius[i];
    m_Index[i] -= static_cast<long>(radius[i]);
    }
}

template<unsigned int VImageDimension>
bool
ImageRegion<VImageDimension>
::Crop(const Self& region)
{
  long crop;
  unsigned int i;
  bool cropPossible = true;


  if (false) { } else for (i = 0; i < VImageDimension && cropPossible; i++)
    {


    if (m_Index[i] >= region.GetIndex()[i]
        + static_cast<long>(region.GetSize()[i]))
      {
      cropPossible = false;
      }


    if (m_Index[i] + static_cast<long>(m_Size[i]) <= region.GetIndex()[i])
      {
      cropPossible = false;
      }
    }


  if (!cropPossible)
    {
    return cropPossible;
    }


  if (false) { } else for (i=0; i < VImageDimension; i++)
    {

    if (m_Index[i] < region.GetIndex()[i])
      {

      crop = region.GetIndex()[i] - m_Index[i];


      m_Index[i] += crop;
      m_Size[i] -= static_cast<unsigned long>(crop);
      }

    if (m_Index[i] + static_cast<long>(m_Size[i])
        > region.GetIndex()[i] + static_cast<long>(region.GetSize()[i]))
      {

      crop = m_Index[i] + static_cast<long>(m_Size[i])
        - region.GetIndex()[i] - static_cast<long>(region.GetSize()[i]);


      m_Size[i] -= static_cast<unsigned long>(crop);
      }
    }

  return cropPossible;
}


template<unsigned int VImageDimension>
typename ImageRegion<VImageDimension>::SliceRegion
ImageRegion<VImageDimension>
::Slice(const unsigned long dim) const
{
  Index<SliceDimension> sliceIndex;
  Size<SliceDimension> sliceSize;

  unsigned int ii = 0;
  if (false) { } else for (unsigned int i=0; i < VImageDimension; i++)
    {
    if (i != dim)
      {
      sliceIndex[ii] = m_Index[i];
      sliceSize[ii] = m_Size[i];
      ++ii;
      }
    }

  return ImageRegion<SliceDimension>(sliceIndex, sliceSize);
}


}
# 282 "/tmp/installed/include/InsightToolkit/Common/itkImageRegion.h" 2
# 31 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 2

namespace itk
{







template <typename TImage>
struct GetImageDimension
{
  static const unsigned int ImageDimension = TImage::ImageDimension;
};
# 75 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
template<unsigned int VImageDimension=2>
class ImageBase : public DataObject
{
public:

  typedef ImageBase Self;
  typedef DataObject Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "ImageBase";};





  static const unsigned int ImageDimension = VImageDimension;


  typedef Index<VImageDimension> IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;



  typedef Offset<VImageDimension> OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;


  typedef Size<VImageDimension> SizeType;
  typedef typename SizeType::SizeValueType SizeValueType;


  typedef ImageRegion<VImageDimension> RegionType;



  typedef Vector<double, VImageDimension> SpacingType;



  typedef Point<double, VImageDimension> PointType;


  void Initialize();


  static unsigned int GetImageDimension()
    { return VImageDimension; }





  virtual const SpacingType & GetSpacing () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" ", line " << 132 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "Spacing" " of " << this->m_Spacing << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_Spacing; };





  virtual const PointType & GetOrigin () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" ", line " << 138 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "Origin" " of " << this->m_Origin << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_Origin; };







  virtual void SetLargestPossibleRegion(const RegionType &region);







  virtual const RegionType& GetLargestPossibleRegion() const
    { return m_LargestPossibleRegion;};




  virtual void SetBufferedRegion(const RegionType &region);




  virtual const RegionType& GetBufferedRegion() const
  { return m_BufferedRegion;};
# 175 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  virtual void SetRequestedRegion(const RegionType &region);
# 184 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  virtual void SetRequestedRegion(DataObject *data);





  virtual const RegionType& GetRequestedRegion() const
  { return m_RequestedRegion;};
# 203 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  const OffsetValueType *GetOffsetTable() const { return m_OffsetTable; };







  OffsetValueType ComputeOffset(const IndexType &ind) const
  {

    OffsetValueType offset=0;
    const IndexType &bufferedRegionIndex = m_BufferedRegion.GetIndex();



    if (false) { } else for (int i=VImageDimension-1; i > 0; i--)
      {
      offset += (ind[i] - bufferedRegionIndex[i])*m_OffsetTable[i];
      }
    offset += (ind[0] - bufferedRegionIndex[0]);

    return offset;
  }
# 235 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  IndexType ComputeIndex(OffsetValueType offset) const
  {
    IndexType index;
    const IndexType &bufferedRegionIndex = m_BufferedRegion.GetIndex();

    if (false) { } else for (int i=VImageDimension-1; i > 0; i--)
      {
      index[i] = static_cast<IndexValueType>(offset / m_OffsetTable[i]);
      offset -= (index[i] * m_OffsetTable[i]);
      index[i] += bufferedRegionIndex[i];
      }
    index[0] = bufferedRegionIndex[0] + static_cast<IndexValueType>(offset);

    return index;
  }
# 260 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  virtual void CopyInformation(const DataObject *data);
# 272 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  virtual void Graft(const ImageBase<VImageDimension> *data);
# 281 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  virtual void UpdateOutputInformation();




  virtual void SetRequestedRegionToLargestPossibleRegion();
# 297 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
# 307 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h"
  virtual bool VerifyRequestedRegion();

protected:
  ImageBase();
  ~ImageBase();
  virtual void PrintSelf(std::ostream& os, Indent indent) const;





  void ComputeOffsetTable();

protected:


  SpacingType m_Spacing;
  PointType m_Origin;
private:
  ImageBase(const Self&);
  void operator=(const Self&);

  OffsetValueType m_OffsetTable[VImageDimension+1];

  RegionType m_LargestPossibleRegion;
  RegionType m_RequestedRegion;
  RegionType m_BufferedRegion;
};






}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.txx" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.txx"
#define _itkImageBase_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 1
# 23 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.txx" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkFastMutexLock.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkFastMutexLock.h"
#define __itkFastMutexLock_h 





namespace itk
{
# 51 "/tmp/installed/include/InsightToolkit/Common/itkFastMutexLock.h"
class FastMutexLock : public Object
{
public:

  typedef FastMutexLock Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "FastMutexLock";};


  void Lock( void );


  void Unlock( void );

protected:
  FastMutexLock() {}
  ~FastMutexLock() {}

  SimpleFastMutexLock m_SimpleFastMutexLock;
  void PrintSelf(std::ostream& os, Indent indent) const;

private:
  FastMutexLock(const Self&);
  void operator=(const Self&);
};


inline void FastMutexLock::Lock( void )
{
  m_SimpleFastMutexLock.Lock();
}

inline void FastMutexLock::Unlock( void )
{
  m_SimpleFastMutexLock.Unlock();
}


}
# 24 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.txx" 2

namespace itk
{




template<unsigned int VImageDimension>
ImageBase<VImageDimension>
::ImageBase()
{
  memset( m_OffsetTable, 0, (VImageDimension+1)*sizeof(unsigned long) );
  m_Spacing.Fill(1.0);
  m_Origin.Fill(0.0);
}





template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::Initialize()
{






  Superclass::Initialize();


  memset( m_OffsetTable, 0, (VImageDimension+1)*sizeof(unsigned long) );


  m_BufferedRegion = RegionType();
}





template<unsigned int VImageDimension>
ImageBase<VImageDimension>
::~ImageBase()
{
}




template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::ComputeOffsetTable()
{
  OffsetValueType num=1;
  const SizeType& bufferSize = m_BufferedRegion.GetSize();

  m_OffsetTable[0] = num;
  if (false) { } else for (unsigned int i=0; i < VImageDimension; i++)
    {
    num *= bufferSize[i];
    m_OffsetTable[i+1] = num;
    }
}



template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::UpdateOutputInformation()
{
  if (this->GetSource())
    {
    this->GetSource()->UpdateOutputInformation();
    }
  else
    {







    if (m_BufferedRegion.GetNumberOfPixels() > 0)
      {
      m_LargestPossibleRegion = m_BufferedRegion;
      }
    }





  if ( m_RequestedRegion.GetNumberOfPixels() == 0)
    {
    this->SetRequestedRegionToLargestPossibleRegion();
    }
}



template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::SetRequestedRegionToLargestPossibleRegion()
{
  m_RequestedRegion = m_LargestPossibleRegion;
}


template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::CopyInformation(const DataObject *data)
{

  Superclass::CopyInformation(data);

  if (data)
    {

    const ImageBase<VImageDimension> *imgData;

    imgData = dynamic_cast<const ImageBase<VImageDimension>*>(data);

    if (imgData)
      {

      m_LargestPossibleRegion = imgData->GetLargestPossibleRegion();
      m_Spacing = imgData->m_Spacing;
      m_Origin = imgData->m_Origin;
      }
    else
      {

      { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "itk::ImageBase::CopyInformation() cannot cast " << typeid(data).name() << " to " << typeid(const ImageBase*).name(); ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/Common/itkImageBase.txx", 167, message.str().c_str()); throw e_; };


      }
    }
}


template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::Graft(const ImageBase<VImageDimension> *data)
{

  this->CopyInformation(data);

  if (data)
    {


    this->SetBufferedRegion( data->GetBufferedRegion() );
    this->SetRequestedRegion( data->GetRequestedRegion() );
    }
}





template<unsigned int VImageDimension>
bool
ImageBase<VImageDimension>
::RequestedRegionIsOutsideOfTheBufferedRegion()
{
  unsigned int i;
  const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
  const IndexType &bufferedRegionIndex = m_BufferedRegion.GetIndex();

  const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
  const SizeType& bufferedRegionSize = m_BufferedRegion.GetSize();

  if (false) { } else for (i=0; i< VImageDimension; i++)
    {
    if ( (requestedRegionIndex[i] < bufferedRegionIndex[i]) ||
         ((requestedRegionIndex[i] + static_cast<OffsetValueType>(requestedRegionSize[i]))
          > (bufferedRegionIndex[i] + static_cast<OffsetValueType>(bufferedRegionSize[i]))) )
      {
      return true;
      }
    }

  return false;
}



template<unsigned int VImageDimension>
bool
ImageBase<VImageDimension>
::VerifyRequestedRegion()
{
  bool retval = true;
  unsigned int i;




  const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
  const IndexType &largestPossibleRegionIndex
    = m_LargestPossibleRegion.GetIndex();

  const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
  const SizeType& largestPossibleRegionSize
    = m_LargestPossibleRegion.GetSize();

  if (false) { } else for (i=0; i< VImageDimension; i++)
    {
    if ( (requestedRegionIndex[i] < largestPossibleRegionIndex[i]) ||
         ((requestedRegionIndex[i] + static_cast<long>(requestedRegionSize[i]))
          > (largestPossibleRegionIndex[i]+static_cast<long>(largestPossibleRegionSize[i]))))
      {
      retval = false;
      }
    }

  return retval;
}


template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::SetBufferedRegion(const RegionType &region)
{
  if (m_BufferedRegion != region)
    {
    m_BufferedRegion = region;
    this->ComputeOffsetTable();
    this->Modified();
    }
}



template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::SetRequestedRegion(const RegionType &region)
{
  if (m_RequestedRegion != region)
    {
    m_RequestedRegion = region;
    }
}


template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::SetRequestedRegion(DataObject *data)
{
  ImageBase *imgData;

  imgData = dynamic_cast<ImageBase*>(data);

  if (imgData)
    {

    m_RequestedRegion = imgData->GetRequestedRegion();
    }
}


template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::SetLargestPossibleRegion(const RegionType &region)
{
  if (m_LargestPossibleRegion != region)
    {
    m_LargestPossibleRegion = region;
    this->Modified();
    }
}






template<unsigned int VImageDimension>
void
ImageBase<VImageDimension>
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  os << indent << "LargestPossibleRegion: " << std::endl;
  m_LargestPossibleRegion.PrintSelf(os, indent.GetNextIndent());

  os << indent << "BufferedRegion: " << std::endl;
  m_BufferedRegion.PrintSelf(os, indent.GetNextIndent());

  os << indent << "RequestedRegion: " << std::endl;
  m_RequestedRegion.PrintSelf(os, indent.GetNextIndent());

  os << indent << "Spacing: " << m_Spacing << std::endl;

  os << indent << "Origin: " << m_Origin << std::endl;
}

}
# 345 "/tmp/installed/include/InsightToolkit/Common/itkImageBase.h" 2
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImage.h" 2

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h"
#define __itkImportImageContainer_h 



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/utility" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/utility" 3
#define _CPP_UTILITY 1

       
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/utility" 3

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_relops.h" 1 3
# 72 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_relops.h" 3
#define _CPP_BITS_STL_RELOPS_H 1

namespace std
{
  namespace rel_ops
  {
# 90 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_relops.h" 3
template <class _Tp>
inline bool operator!=(const _Tp& __x, const _Tp& __y) {
  return !(__x == __y);
}
# 103 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_relops.h" 3
template <class _Tp>
inline bool operator>(const _Tp& __x, const _Tp& __y) {
  return __y < __x;
}
# 116 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_relops.h" 3
template <class _Tp>
inline bool operator<=(const _Tp& __x, const _Tp& __y) {
  return !(__y < __x);
}
# 129 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_relops.h" 3
template <class _Tp>
inline bool operator>=(const _Tp& __x, const _Tp& __y) {
  return !(__x < __y);
}

  }
}
# 67 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/utility" 2 3
# 23 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h" 2

namespace itk
{
# 44 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h"
template <typename TElementIdentifier, typename TElement>
class ImportImageContainer: public Object
{
public:

  typedef ImportImageContainer Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  typedef TElementIdentifier ElementIdentifier;
  typedef TElement Element;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "ImportImageContainer";};


  TElement *GetImportPointer() {return m_ImportPointer;};







  void SetImportPointer(TElement *ptr, TElementIdentifier num,
                        bool LetContainerManageMemory = false);


  TElement & operator[](const ElementIdentifier id)
    { return m_ImportPointer[id]; };


  const TElement & operator[](const ElementIdentifier id) const
    { return m_ImportPointer[id]; };



  TElement *GetBufferPointer()
    { return m_ImportPointer; };


  unsigned long Size(void) const
    { return (unsigned long) m_Size; };
# 101 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h"
  void Reserve(ElementIdentifier num);







  void Squeeze(void);


  void Initialize(void);
# 124 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h"
  virtual void SetContainerManageMemory (const bool _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h" ", line " << 124 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "ContainerManageMemory" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_ContainerManageMemory != _arg) { this->m_ContainerManageMemory = _arg; this->Modified(); } };
  virtual bool GetContainerManageMemory () { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h" ", line " << 125 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "ContainerManageMemory" " of " << this->m_ContainerManageMemory << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_ContainerManageMemory; };
  virtual void ContainerManageMemoryOn () { this->SetContainerManageMemory(true);} virtual void ContainerManageMemoryOff () { this->SetContainerManageMemory(false);};


protected:
  ImportImageContainer();
  virtual ~ImportImageContainer();




  void PrintSelf(std::ostream& os, Indent indent) const;

  TElement* AllocateElements(ElementIdentifier size) const;
private:
  ImportImageContainer(const Self&);
  void operator=(const Self&);

  TElement *m_ImportPointer;
  TElementIdentifier m_Size;
  TElementIdentifier m_Capacity;
  bool m_ContainerManageMemory;

};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.txx" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.txx"
#define _itkImportImageContainer_txx 

namespace itk
{

template <typename TElementIdentifier, typename TElement>
ImportImageContainer<TElementIdentifier , TElement>
::ImportImageContainer()
{
  m_ImportPointer = 0;
  m_ContainerManageMemory = true;
  m_Capacity = 0;
  m_Size = 0;
}


template <typename TElementIdentifier, typename TElement>
ImportImageContainer< TElementIdentifier , TElement >
::~ImportImageContainer()
{
  if (m_ImportPointer && m_ContainerManageMemory)
    {
    delete [] m_ImportPointer;
    }
}






template <typename TElementIdentifier, typename TElement>
void
ImportImageContainer< TElementIdentifier , TElement >
::Reserve(ElementIdentifier size)
{
  if (m_ImportPointer)
    {
    if (size > m_Capacity)
      {
      TElement* temp = this->AllocateElements(size);

      memcpy(temp, m_ImportPointer, m_Size*sizeof(TElement));
      if (m_ImportPointer && m_ContainerManageMemory)
        {
        delete [] m_ImportPointer;
        }
      m_ImportPointer = temp;
      m_ContainerManageMemory = true;
      m_Capacity = size;
      m_Size = size;
      this->Modified();
      }
    }
  else
    {
    m_ImportPointer = this->AllocateElements(size);
    m_Capacity = size;
    m_Size = size;
    m_ContainerManageMemory = true;
    this->Modified();
    }
}






template <typename TElementIdentifier, typename TElement>
void
ImportImageContainer< TElementIdentifier , TElement >
::Squeeze(void)
{
  if (m_ImportPointer)
    {
    if (m_Size < m_Capacity)
      {
      TElement* temp = this->AllocateElements(m_Size);
      memcpy(temp, m_ImportPointer, m_Size*sizeof(TElement));
      if (m_ContainerManageMemory)
        {
        delete [] m_ImportPointer;
        }
      m_ImportPointer = temp;
      m_ContainerManageMemory = true;
      m_Capacity = m_Size;

      this->Modified();
      }
    }
}






template <typename TElementIdentifier, typename TElement>
void
ImportImageContainer< TElementIdentifier , TElement >
::Initialize(void)
{
  if (m_ImportPointer)
    {
    if (m_ContainerManageMemory)
      {
      delete [] m_ImportPointer;
      }
    m_ImportPointer = 0;
    m_ContainerManageMemory = true;
    m_Capacity = 0;
    m_Size = 0;

    this->Modified();
    }
}
# 148 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.txx"
template <typename TElementIdentifier, typename TElement>
void
ImportImageContainer< TElementIdentifier , TElement >
::SetImportPointer(TElement *ptr, TElementIdentifier num,
                   bool LetContainerManageMemory)
{
  if (m_ImportPointer && m_ContainerManageMemory)
    {
    delete [] m_ImportPointer;
    }
  m_ImportPointer = ptr;
  m_ContainerManageMemory = LetContainerManageMemory;
  m_Capacity = num;
  m_Size = num;

  this->Modified();
}

template <typename TElementIdentifier, typename TElement>
TElement* ImportImageContainer< TElementIdentifier , TElement >
::AllocateElements(ElementIdentifier size) const
{



  TElement* data;
  try
    {
    data = new TElement[size];
    }
  catch(...)
    {
    data = 0;
    }
  if(!data)
    {


    throw MemoryAllocationError("/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.txx", 186,
                                "Failed to allocate memory for image.",
                                "ImportImageContainer::AllocateElements");
    }
  return data;
}

template <typename TElementIdentifier, typename TElement>
void
ImportImageContainer< TElementIdentifier , TElement >
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  os << indent << "Pointer: " << &m_ImportPointer << std::endl;
  os << indent << "Container manages memory: "
     << (m_ContainerManageMemory ? "true" : "false") << std::endl;
  os << indent << "Size: " << m_Size << std::endl;
  os << indent << "Capacity: " << m_Capacity << std::endl;
}

}
# 154 "/tmp/installed/include/InsightToolkit/Common/itkImportImageContainer.h" 2
# 23 "/tmp/installed/include/InsightToolkit/Common/itkImage.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkDefaultPixelAccessor.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkDefaultPixelAccessor.h"
#define __itkDefaultPixelAccessor_h 



namespace itk
{
# 52 "/tmp/installed/include/InsightToolkit/Common/itkDefaultPixelAccessor.h"
template <class TType>
class DefaultPixelAccessor
{
public:



  typedef TType ExternalType ;



  typedef TType InternalType ;


  inline void Set(TType & output, const TType & input) const
    {output = input;}


  inline TType & Get( TType & input ) const
    {return input;}


  inline const TType & Get( const TType & input ) const
    {return input;}

};


}
# 24 "/tmp/installed/include/InsightToolkit/Common/itkImage.h" 2





namespace itk
{
# 80 "/tmp/installed/include/InsightToolkit/Common/itkImage.h"
template <class TPixel, unsigned int VImageDimension=2>
class Image : public ImageBase<VImageDimension>
{
public:

  typedef Image Self;
  typedef ImageBase<VImageDimension> Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;
  typedef WeakPointer<const Self> ConstWeakPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "Image";};



  typedef TPixel PixelType;


  typedef TPixel ValueType ;





  typedef TPixel InternalPixelType;



  typedef DefaultPixelAccessor< PixelType > AccessorType;





  static const unsigned int ImageDimension = VImageDimension;


  typedef ImportImageContainer<unsigned long, PixelType> PixelContainer;


  typedef typename Superclass::IndexType IndexType;


  typedef typename Superclass::OffsetType OffsetType;


  typedef typename Superclass::SizeType SizeType;


  typedef typename Superclass::RegionType RegionType;



  typedef typename Superclass::SpacingType SpacingType;



  typedef typename Superclass::PointType PointType;


  typedef typename PixelContainer::Pointer PixelContainerPointer;
  typedef typename PixelContainer::ConstPointer PixelContainerConstPointer;



  void Allocate();




  void SetRegions(RegionType region)
    {
    this->SetLargestPossibleRegion(region);
    this->SetBufferedRegion(region);
    this->SetRequestedRegion(region);
    };

  void SetRegions(SizeType size)
    {
    RegionType region; region.SetSize(size);
    this->SetLargestPossibleRegion(region);
    this->SetBufferedRegion(region);
    this->SetRequestedRegion(region);
    };



  virtual void Initialize();



  void FillBuffer (const TPixel& value);






  void SetPixel(const IndexType &index, const TPixel& value)
    {
    typename Superclass::OffsetValueType offset = this->ComputeOffset(index);
    (*m_Buffer)[offset] = value;
    }





  const TPixel& GetPixel(const IndexType &index) const
  {
    typename Superclass::OffsetValueType offset = this->ComputeOffset(index);
    return ( (*m_Buffer)[offset] );
  }





  TPixel& GetPixel(const IndexType &index)
    {
    typename Superclass::OffsetValueType offset = this->ComputeOffset(index);
    return ( (*m_Buffer)[offset] );
    }





  TPixel & operator[](const IndexType &index)
     { return this->GetPixel(index); }





  const TPixel& operator[](const IndexType &index) const
     { return this->GetPixel(index); }



  TPixel *GetBufferPointer()
    { return m_Buffer ? m_Buffer->GetBufferPointer() : 0; }
  const TPixel *GetBufferPointer() const
    { return m_Buffer ? m_Buffer->GetBufferPointer() : 0; }


  PixelContainer* GetPixelContainer()
    { return m_Buffer.GetPointer(); }

  const PixelContainer* GetPixelContainer() const
    { return m_Buffer.GetPointer(); }



  void SetPixelContainer( PixelContainer *container );
# 250 "/tmp/installed/include/InsightToolkit/Common/itkImage.h"
  virtual void Graft(const ImageBase<VImageDimension> *data);



  AccessorType GetPixelAccessor( void )
    { return AccessorType(); }


  const AccessorType GetPixelAccessor( void ) const
    { return AccessorType(); }





  virtual void SetSpacing (const SpacingType _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImage.h" ", line " << 265 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "Spacing" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_Spacing != _arg) { this->m_Spacing = _arg; this->Modified(); } };
  virtual void SetSpacing( const double spacing[VImageDimension] );
  virtual void SetSpacing( const float spacing[VImageDimension] );





  virtual void SetOrigin (const PointType _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImage.h" ", line " << 273 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "Origin" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_Origin != _arg) { this->m_Origin = _arg; this->Modified(); } };
  virtual void SetOrigin( const double origin[VImageDimension] );
  virtual void SetOrigin( const float origin[VImageDimension] );





  template<class TCoordRep>
  bool TransformPhysicalPointToContinuousIndex(
              const Point<TCoordRep, VImageDimension>& point,
              ContinuousIndex<TCoordRep, VImageDimension>& index ) const
    {

    if (false) { } else for (unsigned int i = 0 ; i < VImageDimension ; i++)
      {
      index[i] = static_cast<TCoordRep>( (point[i]- this->m_Origin[i]) / this->m_Spacing[i] );
      }


    const bool isInside =
      this->GetLargestPossibleRegion().IsInside( index );

    return isInside;
    }





  template<class TCoordRep>
  bool TransformPhysicalPointToIndex(
            const Point<TCoordRep, VImageDimension>& point,
            IndexType & index ) const
    {
    typedef typename IndexType::IndexValueType IndexValueType;


    if (false) { } else for (unsigned int i = 0 ; i < VImageDimension ; i++)
      {
      index[i] = static_cast<IndexValueType>( (point[i]- this->m_Origin[i]) / this->m_Spacing[i] );
      }


    const bool isInside =
      this->GetLargestPossibleRegion().IsInside( index );

    return isInside;
    }





  template<class TCoordRep>
  void TransformContinuousIndexToPhysicalPoint(
            const ContinuousIndex<TCoordRep, VImageDimension>& index,
            Point<TCoordRep, VImageDimension>& point ) const
    {
    if (false) { } else for (unsigned int i = 0 ; i < VImageDimension ; i++)
      {
      point[i] = static_cast<TCoordRep>( this->m_Spacing[i] * index[i] + this->m_Origin[i] );
      }
    }






  template<class TCoordRep>
  void TransformIndexToPhysicalPoint(
                      const IndexType & index,
                      Point<TCoordRep, VImageDimension>& point ) const
    {
    if (false) { } else for (unsigned int i = 0 ; i < VImageDimension ; i++)
      {
      point[i] = static_cast<TCoordRep>( this->m_Spacing[i] *
        static_cast<double>( index[i] ) + this->m_Origin[i] );
      }
    }

protected:
  Image();
  void PrintSelf(std::ostream& os, Indent indent) const;
  virtual ~Image() {};
private:
  Image(const Self&);
  void operator=(const Self&);


  PixelContainerPointer m_Buffer;
};
# 384 "/tmp/installed/include/InsightToolkit/Common/itkImage.h"
}

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImage.txx" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImage.txx"
#define _itkImage_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImage.h" 1
# 23 "/tmp/installed/include/InsightToolkit/Common/itkImage.txx" 2

# 1 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h" 1
# 19 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
#define __itkAffineTransform_h 



# 1 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.h"
#define __itkMatrix_h 




# 1 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.h"
#define __itkCovariantVector_h 
# 27 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.h"
namespace itk
{
# 63 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.h"
template<class T, unsigned int NVectorDimension=3>
class CovariantVector : public FixedArray<T,NVectorDimension>
{
 public:

  typedef CovariantVector Self;
  typedef FixedArray<T,NVectorDimension> Superclass;



  typedef T ValueType;
  typedef typename NumericTraits< ValueType >::RealType RealValueType;


  static const unsigned int Dimension = NVectorDimension;


  typedef Self CovariantVectorType;


  typedef FixedArray<T, NVectorDimension> BaseArray;


  static unsigned int GetCovariantVectorDimension()
    { return NVectorDimension; }


  void Set_vnl_vector( const vnl_vector<T> & );


  vnl_vector_ref<T> Get_vnl_vector( void );


  vnl_vector<T> Get_vnl_vector( void ) const;


  CovariantVector() {}


  CovariantVector(const Self& r): BaseArray(r) {}
  CovariantVector(const ValueType r[Dimension]): BaseArray(r) {}


  CovariantVector& operator= (const Self& r);
  CovariantVector& operator= (const ValueType r[Dimension]);


  const Self& operator*=(const ValueType &value);


  const Self& operator/=(const ValueType &value);


  const Self& operator+=(const Self &vec);


  const Self& operator-=(const Self &vec);


  Self operator-() const;


  Self operator+(const Self &vec) const;


  Self operator-(const Self &vec) const;



  Self operator*(const ValueType& val) const;




  ValueType operator*(const Self &vec) const;



  ValueType operator*(const Vector<T,NVectorDimension> &vec) const;



  Self operator/(const ValueType& val) const;


  RealValueType GetNorm( void ) const;


  void Normalize(void);


  RealValueType GetSquaredNorm( void ) const;


  void PrintSelf(std::ostream& os, Indent indent) const;



  template < typename TCoordRepB >
  void CastFrom( const CovariantVector<TCoordRepB,NVectorDimension> & pa )
  {
    if (false) { } else for(unsigned int i=0; i<NVectorDimension; i++ )
      {
      (*this)[i] = static_cast<T>( pa[i] );
      }
  }


};


}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.txx"
#define _itkCovariantVector_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.txx" 2



namespace itk
{


template<class T, unsigned int NVectorDimension>
CovariantVector<T, NVectorDimension>&
CovariantVector<T, NVectorDimension>
::operator= (const Self& r)
{
  BaseArray::operator=(r);
  return *this;
}


template<class T, unsigned int NVectorDimension>
CovariantVector<T, NVectorDimension>&
CovariantVector<T, NVectorDimension>
::operator= (const ValueType r[Dimension])
{
  BaseArray::operator=(r);
  return *this;
}





template<class T, unsigned int NVectorDimension>
const CovariantVector<T, NVectorDimension> &
CovariantVector<T, NVectorDimension>
::operator*=( const ValueType & value )
{
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    (*this)[i] *= value;
    }
  return *this;
}





template<class T, unsigned int NVectorDimension>
const CovariantVector<T, NVectorDimension> &
CovariantVector<T, NVectorDimension>
::operator/=( const ValueType & value )
{
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    (*this)[i] /= value;
    }
  return *this;
}





template<class T, unsigned int NVectorDimension>
const typename CovariantVector<T, NVectorDimension>::Self &
CovariantVector<T, NVectorDimension>
::operator+=( const Self & vec )
{
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    (*this)[i] += vec[i];
    }
  return *this;
}





template<class T, unsigned int NVectorDimension>
const typename CovariantVector<T, NVectorDimension>::Self &
CovariantVector<T, NVectorDimension>
::operator-=( const Self & vec )
{
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    (*this)[i] -= vec[i];
    }
  return *this;
}





template<class T, unsigned int NVectorDimension>
CovariantVector<T, NVectorDimension>
CovariantVector<T, NVectorDimension>
::operator-() const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    result[i] = -(*this)[i];
    }
  return result;
}






template<class T, unsigned int NVectorDimension>
typename CovariantVector<T, NVectorDimension>::Self
CovariantVector<T, NVectorDimension>
::operator+( const Self & vec ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    result[i] = (*this)[i] + vec[i];
    }
  return result;
}






template<class T, unsigned int NVectorDimension>
typename CovariantVector<T, NVectorDimension>::Self
CovariantVector<T, NVectorDimension>
::operator-( const Self & vec ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    result[i] = (*this)[i] - vec[i];
    }
  return result;
}






template<class T, unsigned int NVectorDimension>
CovariantVector<T, NVectorDimension>
CovariantVector<T, NVectorDimension>
::operator*( const ValueType & value ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    result[i] = (*this)[i] * value;
    }
  return result;
}





template<class T, unsigned int NVectorDimension>
typename CovariantVector<T, NVectorDimension>::ValueType
CovariantVector<T, NVectorDimension>
::operator*( const Self & other ) const
{
  typename NumericTraits<T>::AccumulateType value = NumericTraits<T>::Zero;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    value += (*this)[i] * other[i];
    }
  return static_cast< ValueType >( value );
}





template<class T, unsigned int NVectorDimension>
typename CovariantVector<T, NVectorDimension>::ValueType
CovariantVector<T, NVectorDimension>
::operator*( const Vector<T,NVectorDimension> & other ) const
{
  typename NumericTraits<T>::AccumulateType value = NumericTraits<T>::Zero;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    value += (*this)[i] * other[i];
    }
  return value;
}






template<class T, unsigned int NVectorDimension>
typename CovariantVector<T, NVectorDimension>::RealValueType
CovariantVector<T, NVectorDimension>
::GetSquaredNorm( void ) const
{
  RealValueType sum = NumericTraits<RealValueType>::Zero;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    const RealValueType value = (*this)[i];
    sum += value * value;
    }
  return sum;
}






template<class T, unsigned int NVectorDimension>
typename CovariantVector<T, NVectorDimension>::RealValueType
CovariantVector<T, NVectorDimension>
::GetNorm( void ) const
{
  return sqrt( this->GetSquaredNorm() );
}






template<class T, unsigned int NVectorDimension>
CovariantVector<T, NVectorDimension>
CovariantVector<T, NVectorDimension>
::operator/( const ValueType & value ) const
{
  Self result;
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    result[i] = (*this)[i] / value;
    }
  return result;
}





template<class T, unsigned int NVectorDimension>
void
CovariantVector<T, NVectorDimension>
::Normalize( void )
{
  const RealValueType norm = this->GetNorm();
  if (false) { } else for( unsigned int i=0; i<NVectorDimension; i++)
    {
    (*this)[i] /= norm;
    }
}






template<class T, unsigned int NVectorDimension >
void
CovariantVector<T, NVectorDimension >
::Set_vnl_vector( const vnl_vector<T> & v)
{
  if (false) { } else for(unsigned int i=0;i<v.size();i++)
    {
    (*this)[i] = v(i);
    }
}





template<class T, unsigned int NVectorDimension>
vnl_vector_ref< T >
CovariantVector<T, NVectorDimension>
::Get_vnl_vector( void )
{
  return vnl_vector_ref< T >( NVectorDimension, this->GetDataPointer() );
}





template<class T, unsigned int NVectorDimension>
vnl_vector< T >
CovariantVector<T, NVectorDimension>
::Get_vnl_vector( void ) const
{




  return vnl_vector_ref<T>( NVectorDimension,
                            const_cast<T*>(this->GetDataPointer()));
}



}
# 179 "/tmp/installed/include/InsightToolkit/Common/itkCovariantVector.h" 2
# 24 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h" 1


#define vnl_matrix_fixed_h_ 
# 26 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cassert.h" 1
# 27 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h" 2


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h" 1


#define vnl_matrix_h_ 
# 18 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cassert.h" 1
# 19 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h" 2







 template <class T> class vnl_vector;
 template <class T> class vnl_matrix;




#define v vnl_vector<T>
#define m vnl_matrix<T>

template <class T> vnl_matrix<T> operator+ (T const&, vnl_matrix<T> const&);
template <class T> vnl_matrix<T> operator- (T const&, vnl_matrix<T> const&);
template <class T> vnl_matrix<T> operator* (T const&, vnl_matrix<T> const&);
template <class T> vnl_matrix<T> element_product(vnl_matrix<T> const&, vnl_matrix<T> const&);
template <class T> vnl_matrix<T> element_quotient(vnl_matrix<T> const&, vnl_matrix<T> const&);
template <class T> T dot_product (vnl_matrix<T> const&, vnl_matrix<T> const&);
template <class T> T inner_product (vnl_matrix<T> const&, vnl_matrix<T> const&);
template <class T> T cos_angle(vnl_matrix<T> const&, vnl_matrix<T> const& );
template <class T> std :: ostream& operator<< (std :: ostream&, vnl_matrix<T> const&);
template <class T> std :: istream& operator>> (std :: istream&, vnl_matrix<T>&);
#undef v
#undef m



enum vnl_matrix_type
{
  vnl_matrix_null,
  vnl_matrix_identity
};
# 82 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h"
template<class T>
class vnl_matrix
{
 public:

  vnl_matrix () :
    num_rows(0),
    num_cols(0),
    data(0)
  {
  }




  vnl_matrix(unsigned r, unsigned c);



  vnl_matrix(unsigned r, unsigned c, T const& v0);




  vnl_matrix(unsigned r, unsigned c, vnl_matrix_type t);




  vnl_matrix(unsigned r, unsigned c, unsigned n, T const values[]);




  vnl_matrix(T const* data_block, unsigned r, unsigned c);



  vnl_matrix(vnl_matrix<T> const&);





  vnl_matrix (vnl_matrix<T> const &, vnl_matrix<T> const &, vnl_tag_add);
  vnl_matrix (vnl_matrix<T> const &, vnl_matrix<T> const &, vnl_tag_sub);
  vnl_matrix (vnl_matrix<T> const &, T, vnl_tag_mul);
  vnl_matrix (vnl_matrix<T> const &, T, vnl_tag_div);
  vnl_matrix (vnl_matrix<T> const &, T, vnl_tag_add);
  vnl_matrix (vnl_matrix<T> const &, T, vnl_tag_sub);
  vnl_matrix (vnl_matrix<T> const &, vnl_matrix<T> const &, vnl_tag_mul);
  vnl_matrix (vnl_matrix<T> &that, vnl_tag_grab)
    : num_rows(that.num_rows), num_cols(that.num_cols), data(that.data)
  { that.num_cols=that.num_rows=0; that.data=0; }




  ~vnl_matrix();




  unsigned rows () const { return num_rows; }



 unsigned columns () const { return num_cols; }



  unsigned cols () const { return num_cols; }



  unsigned size () const { return rows()*cols(); }


  void put (unsigned r, unsigned c, T const&);


  T get (unsigned r, unsigned c) const;



  T * operator[] (unsigned r) { return data[r]; }



  T const * operator[] (unsigned r) const { return data[r]; }



  T & operator() (unsigned r, unsigned c)
  {

    (static_cast<void> (__builtin_expect (!!(r<rows()), 1) ? 0 : (__assert_fail ("r<rows()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h", 178, __PRETTY_FUNCTION__), 0)));
    (static_cast<void> (__builtin_expect (!!(c<cols()), 1) ? 0 : (__assert_fail ("c<cols()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h", 179, __PRETTY_FUNCTION__), 0)));

    return this->data[r][c];
  }



  T const & operator() (unsigned r, unsigned c) const
  {

    (static_cast<void> (__builtin_expect (!!(r<rows()), 1) ? 0 : (__assert_fail ("r<rows()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h", 189, __PRETTY_FUNCTION__), 0)));
    (static_cast<void> (__builtin_expect (!!(c<cols()), 1) ? 0 : (__assert_fail ("c<cols()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h", 190, __PRETTY_FUNCTION__), 0)));

    return this->data[r][c];
  }






  void fill (T const&);



  void fill_diagonal (T const&);



  void copy_in(T const *);



  void set(T const *d) { copy_in(d); }





  void copy_out(T *) const;




  vnl_matrix<T>& operator= (T const&v) { fill(v); return *this; }



  vnl_matrix<T>& operator= (vnl_matrix<T> const&);






  vnl_matrix<T>& operator+= (T value);


  vnl_matrix<T>& operator-= (T value);


  vnl_matrix<T>& operator*= (T value);


  vnl_matrix<T>& operator/= (T value);


  vnl_matrix<T>& operator+= (vnl_matrix<T> const&);

  vnl_matrix<T>& operator-= (vnl_matrix<T> const&);

  vnl_matrix<T>& operator*= (vnl_matrix<T> const&rhs) { *this = (*this) * rhs; return *this; }


  vnl_matrix<T> operator- () const;



  vnl_matrix<T> operator+ (T const& v) const { return vnl_matrix<T>(*this, v, vnl_tag_add()); }


  vnl_matrix<T> operator- (T const& v) const { return vnl_matrix<T>(*this, v, vnl_tag_sub()); }


  vnl_matrix<T> operator* (T const& v) const { return vnl_matrix<T>(*this, v, vnl_tag_mul()); }


  vnl_matrix<T> operator/ (T const& v) const { return vnl_matrix<T>(*this, v, vnl_tag_div()); }


  vnl_matrix<T> operator+ (vnl_matrix<T> const& rhs) const { return vnl_matrix<T>(*this, rhs, vnl_tag_add()); }

  vnl_matrix<T> operator- (vnl_matrix<T> const& rhs) const { return vnl_matrix<T>(*this, rhs, vnl_tag_sub()); }

  vnl_matrix<T> operator* (vnl_matrix<T> const& rhs) const { return vnl_matrix<T>(*this, rhs, vnl_tag_mul()); }




  vnl_matrix<T> apply(T (*f)(T)) const;


  vnl_matrix<T> apply(T (*f)(T const&)) const;


  vnl_matrix<T> transpose () const;


  vnl_matrix<T> conjugate_transpose () const;


  vnl_matrix<T>& update (vnl_matrix<T> const&, unsigned top=0, unsigned left=0);


  void set_column(unsigned i, T const * v);


  void set_column(unsigned i, T value );


  void set_column(unsigned j, vnl_vector<T> const& v);


  void set_columns(unsigned starting_column, vnl_matrix<T> const& M);


  void set_row (unsigned i, T const * v);


  void set_row (unsigned i, T value );


  void set_row (unsigned i, vnl_vector<T> const&);



  vnl_matrix<T> extract (unsigned rows, unsigned cols,
                         unsigned top=0, unsigned left=0) const;


  vnl_vector<T> get_row (unsigned row) const;


  vnl_vector<T> get_column(unsigned col) const;


  vnl_matrix<T> get_n_rows (unsigned rowstart, unsigned n) const;


  vnl_matrix<T> get_n_columns(unsigned colstart, unsigned n) const;






  void set_identity();


  void inplace_transpose();


  void flipud();

  void fliplr();



  void normalize_rows();



  void normalize_columns();


  void scale_row (unsigned row, T value);


  void scale_column(unsigned col, T value);


  void swap(vnl_matrix<T> & that);


  typedef typename vnl_c_vector<T>::abs_t abs_t;


  abs_t array_one_norm() const { return vnl_c_vector<T>::one_norm(begin(), size()); }


  abs_t array_two_norm() const { return vnl_c_vector<T>::two_norm(begin(), size()); }


  abs_t array_inf_norm() const { return vnl_c_vector<T>::inf_norm(begin(), size()); }


  abs_t absolute_value_sum() const { return array_one_norm(); }


  abs_t absolute_value_max() const { return array_inf_norm(); }


  abs_t operator_one_norm() const;


  abs_t operator_inf_norm() const;


  abs_t frobenius_norm() const { return vnl_c_vector<T>::two_norm(begin(), size()); }


  abs_t fro_norm() const { return frobenius_norm(); }


  abs_t rms() const { return vnl_c_vector<T>::rms_norm(begin(), size()); }


  T min_value() const { return vnl_c_vector<T>::min_value(begin(), size()); }


  T max_value() const { return vnl_c_vector<T>::max_value(begin(), size()); }


  T mean() const { return vnl_c_vector<T>::mean(begin(), size()); }




  bool empty() const { return !data || !num_rows || !num_cols; }


  bool is_identity() const;


  bool is_identity(double tol) const;


  bool is_zero() const;


  bool is_zero(double tol) const;


  bool is_finite() const;


  bool has_nans() const;



  void assert_size(unsigned rows, unsigned cols) const
  {

    assert_size_internal(rows, cols);

  }


  void assert_finite() const
  {

    assert_finite_internal();

  }




  static vnl_matrix<T> read(std :: istream& s);


  bool read_ascii(std :: istream& s);





  T const* data_block () const { return data[0]; }



  T * data_block () { return data[0]; }



  T const* const* data_array () const { return data; }



  T * * data_array () { return data; }

  typedef T element_type;


  typedef T *iterator;

  iterator begin() { return data?data[0]:0; }

  iterator end() { return data?data[0]+num_rows*num_cols:0; }


  typedef T const *const_iterator;

  const_iterator begin() const { return data?data[0]:0; }

  const_iterator end() const { return data?data[0]+num_rows*num_cols:0; }





  vnl_matrix<T> const& as_ref() const { return *this; }


  vnl_matrix<T>& as_ref() { return *this; }




  bool operator_eq (vnl_matrix<T> const & rhs) const;


  bool operator==(vnl_matrix<T> const &that) const { return this->operator_eq(that); }


  bool operator!=(vnl_matrix<T> const &that) const { return !this->operator_eq(that); }


  void print(std :: ostream& os) const;


  void clear();

 private:


  bool resize (unsigned , unsigned ) { return false; }



  bool make_size (unsigned , unsigned ) { return false; };
 public:


  bool set_size (unsigned r, unsigned c);



 protected:
  unsigned num_rows;
  unsigned num_cols;
  T** data;







  void assert_size_internal(unsigned rows, unsigned cols) const;
  void assert_finite_internal() const;


  void destroy();
# 562 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h"
  static void inline_function_tickler();
};
# 572 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix.h"
template<class T>
inline T vnl_matrix<T>::get (unsigned row, unsigned column) const
{






  return this->data[row][column];
}




template<class T>
inline void vnl_matrix<T>::put (unsigned row, unsigned column, T const& value)
{






  this->data[row][column] = value;
}






template<class T>
inline vnl_matrix<T> operator* (T const& value, vnl_matrix<T> const& m)
{
  return vnl_matrix<T>(m, value, vnl_tag_mul());
}



template<class T>
inline vnl_matrix<T> operator+ (T const& value, vnl_matrix<T> const& m)
{
  return vnl_matrix<T>(m, value, vnl_tag_add());
}



template<class T>
inline void swap(vnl_matrix<T> &A, vnl_matrix<T> &B) { A.swap(B); }
# 30 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_ref.h" 1


#define vnl_matrix_ref_h_ 
# 37 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_ref.h"
template <class T>
class vnl_matrix_ref : public vnl_matrix<T>
{
  typedef vnl_matrix<T> Base;

 public:

  vnl_matrix_ref(unsigned int m, unsigned int n, T *datablck) {
    Base::data = vnl_c_vector<T>::allocate_Tptr(m);
    if (false) { } else for (unsigned int i = 0; i < m; ++i)
      Base::data[i] = datablck + i * n;
    Base::num_rows = m;
    Base::num_cols = n;



  }

  vnl_matrix_ref(vnl_matrix_ref<T> const & other) : vnl_matrix<T>() {
    Base::data = vnl_c_vector<T>::allocate_Tptr(other.rows());
    if (false) { } else for (unsigned int i = 0; i < other.rows(); ++i)
      Base::data[i] = const_cast<T*>(other.data_block()) + i * other.cols();
    Base::num_rows = other.rows();
    Base::num_cols = other.cols();



  }

  ~vnl_matrix_ref() {
    Base::data[0] = 0;
  }
# 84 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_ref.h"
  vnl_matrix_ref& non_const() { return *this; }
# 101 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_ref.h"
 private:

  bool resize (unsigned int, unsigned int) { return false; }

  bool make_size (unsigned int, unsigned int) { return false; }

  bool set_size (unsigned int, unsigned int) { return false; }



  vnl_matrix_ref(vnl_matrix<T> const &) {}
};
# 31 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h" 2

# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h" 1


#define vnl_vector_fixed_h_ 
# 29 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cstring.h" 1

#define vcl_cstring_h_ 
# 19 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cstring.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cstring.h" 1

#define vcl_iso_cstring_h_ 
# 11 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cstring.h"
#define vcl_generic_cstring_STD std


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_cstring.h" 1

#define vcl_generic_cstring_h_ 






#define vcl_memchr vcl_generic_cstring_STD :: memchr



#define vcl_memcmp vcl_generic_cstring_STD :: memcmp



#define vcl_memcpy vcl_generic_cstring_STD :: memcpy



#define vcl_memmove vcl_generic_cstring_STD :: memmove



#define vcl_memset vcl_generic_cstring_STD :: memset



#define vcl_strcat vcl_generic_cstring_STD :: strcat



#define vcl_strchr vcl_generic_cstring_STD :: strchr



#define vcl_strcmp vcl_generic_cstring_STD :: strcmp



#define vcl_strcoll vcl_generic_cstring_STD :: strcoll



#define vcl_strcpy vcl_generic_cstring_STD :: strcpy



#define vcl_strcspn vcl_generic_cstring_STD :: strcspn



#define vcl_strerror vcl_generic_cstring_STD :: strerror



#define vcl_strlen vcl_generic_cstring_STD :: strlen



#define vcl_strncat vcl_generic_cstring_STD :: strncat



#define vcl_strncmp vcl_generic_cstring_STD :: strncmp



#define vcl_strncpy vcl_generic_cstring_STD :: strncpy



#define vcl_strpbrk vcl_generic_cstring_STD :: strpbrk



#define vcl_strrchr vcl_generic_cstring_STD :: strrchr



#define vcl_strspn vcl_generic_cstring_STD :: strspn



#define vcl_strstr vcl_generic_cstring_STD :: strstr



#define vcl_strtok vcl_generic_cstring_STD :: strtok



#define vcl_strxfrm vcl_generic_cstring_STD :: strxfrm
# 15 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_cstring.h" 2
# 20 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cstring.h" 2
# 30 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cassert.h" 1
# 31 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h" 2
# 78 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h"
template <class T, unsigned int n>
class vnl_vector_fixed
{
 public:
  typedef unsigned int size_type;

 protected:
  T data_[n];

 public:





  vnl_vector_fixed() {}



  vnl_vector_fixed( const vnl_vector_fixed<T,n>& rhs )
  {
    std :: memcpy( data_, rhs.data_, sizeof data_ );
  }



  vnl_vector_fixed( const vnl_vector<T>& rhs )
  {
    (static_cast<void> (__builtin_expect (!!(n == rhs.size()), 1) ? 0 : (__assert_fail ("n == rhs.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 106, __PRETTY_FUNCTION__), 0)));
    std :: memcpy( data_, rhs.data_block(), sizeof data_ );
  }


  explicit vnl_vector_fixed( const T& v ) { fill( v ); }



  explicit vnl_vector_fixed( const T* datablck )
  {
    std :: memcpy( data_, datablck, sizeof data_ );
  }




  vnl_vector_fixed( const T& x0, const T& x1 )
  {
    (static_cast<void> (__builtin_expect (!!(n == 2), 1) ? 0 : (__assert_fail ("n == 2", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 125, __PRETTY_FUNCTION__), 0)));
    data_[0] = x0; data_[1] = x1;
  }




  vnl_vector_fixed( const T& x0, const T& x1, const T& x2 )
  {
    (static_cast<void> (__builtin_expect (!!(n == 3), 1) ? 0 : (__assert_fail ("n == 3", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 134, __PRETTY_FUNCTION__), 0)));
    data_[0] = x0; data_[1] = x1; data_[2] = x2;
  }


  vnl_vector_fixed( const T& x0, const T& x1, const T& x2, const T& x3 )
  {
    (static_cast<void> (__builtin_expect (!!(n == 4), 1) ? 0 : (__assert_fail ("n == 4", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 141, __PRETTY_FUNCTION__), 0)));
    data_[0] = x0; data_[1] = x1; data_[2] = x2; data_[3] = x3;
  }


  vnl_vector_fixed<T,n>& operator=( const vnl_vector_fixed<T,n>& rhs ) {
    std :: memcpy( data_, rhs.data_, sizeof data_ );
    return *this;
  }



  vnl_vector_fixed<T,n>& operator=( const vnl_vector<T>& rhs) {
    (static_cast<void> (__builtin_expect (!!(n == rhs.size()), 1) ? 0 : (__assert_fail ("n == rhs.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 154, __PRETTY_FUNCTION__), 0)));
    std :: memcpy( data_, rhs.data_block(), sizeof data_ );
    return *this;
  }



  unsigned size() const { return n; }


  void put (unsigned int i, T const& v) { data_[i] = v; }


  T get (unsigned int i) const { return data_[i]; }


  void fill( T const& v )
  {
    if (false) { } else for ( size_type i = 0; i < n; ++i )
      data_[i] = v;
  }



  void copy_in( T const * ptr )
  {
    if (false) { } else for ( size_type i = 0; i < n; ++i )
      data_[i] = ptr[i];
  }



  void copy_out( T* ptr ) const
  {
    if (false) { } else for ( size_type i = 0; i < n; ++i )
      ptr[i] = data_[i];
  }



  void set( T const *ptr ) { copy_in(ptr); }




  T & operator() (unsigned int i)
  {

    (static_cast<void> (__builtin_expect (!!(i<n), 1) ? 0 : (__assert_fail ("i<n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 202, __PRETTY_FUNCTION__), 0)));

    return data_[i];
  }



  T const & operator() (unsigned int i) const
  {

    (static_cast<void> (__builtin_expect (!!(i<n), 1) ? 0 : (__assert_fail ("i<n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 212, __PRETTY_FUNCTION__), 0)));

    return data_[i];
  }


  T& operator[] ( unsigned int i ) { return data_[i]; }


  const T& operator[] ( unsigned int i ) const { return data_[i]; }




  T const* data_block() const { return data_; }




  T * data_block() { return data_; }
# 246 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h"
  vnl_vector_ref<T> as_ref() { return vnl_vector_ref<T>( n, data_ ); }






  const vnl_vector_ref<T> as_ref() const { return vnl_vector_ref<T>( n, const_cast<T*>(data_) ); }





  operator const vnl_vector_ref<T>() const { return vnl_vector_ref<T>( n, const_cast<T*>(data_) ); }




  typedef T element_type;

  typedef T *iterator;

  iterator begin() { return data_; }


  iterator end() { return data_+n; }


  typedef T const *const_iterator;

  const_iterator begin() const { return data_; }

  const_iterator end() const { return data_+n; }




  vnl_vector_fixed<T,n> apply(T (*f)(T));



  vnl_vector_fixed<T,n> apply(T (*f)(const T&));


  vnl_vector_fixed<T,n>& operator+=( T s ) { add( data_, s, data_ ); return *this; }


  vnl_vector_fixed<T,n>& operator-=( T s ) { sub( data_, s, data_ ); return *this; }


  vnl_vector_fixed<T,n>& operator*=( T s ) { mul( data_, s, data_ ); return *this; }


  vnl_vector_fixed<T,n>& operator/=( T s ) { div( data_, s, data_ ); return *this; }


  vnl_vector_fixed<T,n>& operator+=( const vnl_vector_fixed<T,n>& v ) { add( data_, v.data_block(), data_ ); return *this; }


  vnl_vector_fixed<T,n>& operator-=( const vnl_vector_fixed<T,n>& v ) { sub( data_, v.data_block(), data_ ); return *this; }


  vnl_vector_fixed<T,n>& operator+=( const vnl_vector<T>& v )
  {
    (static_cast<void> (__builtin_expect (!!(v.size() == n), 1) ? 0 : (__assert_fail ("v.size() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 310, __PRETTY_FUNCTION__), 0)));
    add( data_, v.data_block(), data_ ); return *this;
  }


  vnl_vector_fixed<T,n>& operator-=( const vnl_vector<T>& v )
  {
    (static_cast<void> (__builtin_expect (!!(v.size() == n), 1) ? 0 : (__assert_fail ("v.size() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 317, __PRETTY_FUNCTION__), 0)));
    sub( data_, v.data_block(), data_ ); return *this;
  }


  vnl_vector_fixed<T,n> operator-() const
  {
    vnl_vector_fixed<T,n> result;
    sub( (T)0, data_, result.data_ );
    return result;
  }


  vnl_vector<T> extract (unsigned int len, unsigned int start=0) const;


  vnl_vector<T> as_vector() const { return extract(n); }


  vnl_vector_fixed& update (vnl_vector<T> const&, unsigned int start=0);


  typedef typename vnl_c_vector<T>::abs_t abs_t;


  abs_t squared_magnitude() const { return vnl_c_vector<T>::two_nrm2(begin(), size()); }


  abs_t magnitude() const { return two_norm(); }


  abs_t one_norm() const { return vnl_c_vector<T>::one_norm(begin(), size()); }


  abs_t two_norm() const { return vnl_c_vector<T>::two_norm(begin(), size()); }


  abs_t inf_norm() const { return vnl_c_vector<T>::inf_norm(begin(), size()); }


  vnl_vector_fixed<T,n>& normalize() { vnl_c_vector<T>::normalize(begin(), size()); return *this; }





  abs_t rms () const { return vnl_c_vector<T>::rms_norm(begin(), size()); }


  T min_value () const { return vnl_c_vector<T>::min_value(begin(), size()); }


  T max_value () const { return vnl_c_vector<T>::max_value(begin(), size()); }


  T mean() const { return vnl_c_vector<T>::mean(begin(), size()); }


  T sum() const { return vnl_c_vector<T>::sum(begin(), size()); }



  void flip();



  void assert_size( unsigned sz ) const { (static_cast<void> (__builtin_expect (!!(sz == n), 1) ? 0 : (__assert_fail ("sz == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 383, __PRETTY_FUNCTION__), 0))); }



  void assert_finite() const
  {

    assert_finite_internal();

  }


  bool is_finite() const;


  bool is_zero() const;


  bool empty() const { return n==0; }


  bool operator_eq (vnl_vector_fixed<T,n> const& v) const
  {
    if (false) { } else for ( size_type i = 0; i < n; ++i )
      if ( (*this)[i] != v[i] )
        return false;
    return true;
  }


  bool operator_eq (vnl_vector<T> const& v) const
  {
    (static_cast<void> (__builtin_expect (!!(v.size() == n), 1) ? 0 : (__assert_fail ("v.size() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 415, __PRETTY_FUNCTION__), 0)));
    if (false) { } else for ( size_type i = 0; i < n; ++i )
      if ( (*this)[i] != v[i] )
        return false;
    return true;
  }



  bool read_ascii(std :: istream& s);



  void print( std :: ostream& s ) const;

 public:



  inline static void add( const T* a, const T* b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a,++b )
      *r = *a + *b;
  }

  inline static void add( const T* a, T b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a )
      *r = *a + b;
  }

  inline static void sub( const T* a, const T* b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a,++b )
      *r = *a - *b;
  }

  inline static void sub( const T* a, T b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a )
      *r = *a - b;
  }

  inline static void sub( T a, const T* b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++b )
      *r = a - *b;
  }

  inline static void mul( const T* a, const T* b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a,++b )
      *r = *a * *b;
  }

  inline static void mul( const T* a, T b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a )
      *r = *a * b;
  }

  inline static void div( const T* a, const T* b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a,++b )
      *r = *a / *b;
  }

  inline static void div( const T* a, T b, T* r )
  {
    if (false) { } else for ( unsigned int i=0; i < n; ++i,++r,++a )
      *r = *a / b;
  }

 private:

  void assert_finite_internal() const;
};






template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator+( const vnl_vector_fixed<T,n>& v, T s )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::add( v.data_block(), s, r.data_block() );
  return r;
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator+( T s, const vnl_vector_fixed<T,n>& v )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::add( v.data_block(), s, r.data_block() );
  return r;
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator-( const vnl_vector_fixed<T,n>& v, T s )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::sub( v.data_block(), s, r.data_block() );
  return r;
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator-( T s, const vnl_vector_fixed<T,n>& v )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::sub( s, v.data_block(), r.data_block() );
  return r;
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator*( const vnl_vector_fixed<T,n>& v, T s )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::mul( v.data_block(), s, r.data_block() );
  return r;
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator*( T s, const vnl_vector_fixed<T,n>& v )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::mul( v.data_block(), s, r.data_block() );
  return r;
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator/( const vnl_vector_fixed<T,n>& v, T s )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::div( v.data_block(), s, r.data_block() );
  return r;
}
# 575 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h"
template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator+( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::add( a.data_block(), b.data_block(), r.data_block() );
  return r;
}




template<class T, unsigned int n>
inline vnl_vector<T> operator+( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  return a.as_ref() + b;
}




template<class T, unsigned int n>
inline vnl_vector<T> operator+( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  return a + b.as_ref();
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> operator-( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::sub( a.data_block(), b.data_block(), r.data_block() );
  return r;
}




template<class T, unsigned int n>
inline vnl_vector<T> operator-( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  return a.as_ref() - b;
}




template<class T, unsigned int n>
inline vnl_vector<T> operator-( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  return a - b.as_ref();
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> element_product( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::mul( a.data_block(), b.data_block(), r.data_block() );
  return r;
}




template<class T, unsigned int n>
inline vnl_vector<T> element_product( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  (static_cast<void> (__builtin_expect (!!(b.size() == n), 1) ? 0 : (__assert_fail ("b.size() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 645, __PRETTY_FUNCTION__), 0)));
  vnl_vector<T> r(n);
  vnl_vector_fixed<T,n>::mul( a.data_block(), b.data_block(), r.data_block() );
  return r;
}




template<class T, unsigned int n>
inline vnl_vector<T> element_product( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  (static_cast<void> (__builtin_expect (!!(a.size() == n), 1) ? 0 : (__assert_fail ("a.size() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 657, __PRETTY_FUNCTION__), 0)));
  vnl_vector<T> r(n);
  vnl_vector_fixed<T,n>::mul( a.data_block(), b.data_block(), r.data_block() );
  return r;
}



template<class T, unsigned int n>
inline vnl_vector_fixed<T,n> element_quotient( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  vnl_vector_fixed<T,n> r;
  vnl_vector_fixed<T,n>::div( a.data_block(), b.data_block(), r.data_block() );
  return r;
}




template<class T, unsigned int n>
inline vnl_vector<T> element_quotient( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  (static_cast<void> (__builtin_expect (!!(b.size() == n), 1) ? 0 : (__assert_fail ("b.size() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 679, __PRETTY_FUNCTION__), 0)));
  vnl_vector<T> r(n);
  vnl_vector_fixed<T,n>::div( a.data_block(), b.data_block(), r.data_block() );
  return r;
}




template<class T, unsigned int n>
inline vnl_vector<T> element_quotient( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  (static_cast<void> (__builtin_expect (!!(a.size() == n), 1) ? 0 : (__assert_fail ("a.size() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 691, __PRETTY_FUNCTION__), 0)));
  vnl_vector<T> r(n);
  vnl_vector_fixed<T,n>::div( a.data_block(), b.data_block(), r.data_block() );
  return r;
}



template<class T>
T cross_2d (vnl_vector_fixed<T,2> const& v1, vnl_vector_fixed<T,2> const& v2)
{
  return v1[0] * v2[1] - v1[1] * v2[0];
}




template<class T>
T cross_2d (vnl_vector_fixed<T,2> const& v1, vnl_vector<T> const& v2)
{
  (static_cast<void> (__builtin_expect (!!(v2.size() == 2), 1) ? 0 : (__assert_fail ("v2.size() == 2", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 711, __PRETTY_FUNCTION__), 0)));
  return v1[0] * v2[1] - v1[1] * v2[0];
}




template<class T>
T cross_2d (vnl_vector<T> const& v1, vnl_vector_fixed<T,2> const& v2)
{
  (static_cast<void> (__builtin_expect (!!(v1.size() == 2), 1) ? 0 : (__assert_fail ("v1.size() == 2", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_vector_fixed.h", 721, __PRETTY_FUNCTION__), 0)));
  return v1[0] * v2[1] - v1[1] * v2[0];
}



template<class T>
vnl_vector_fixed<T,3> cross_3d (vnl_vector_fixed<T,3> const& v1, vnl_vector_fixed<T,3> const& v2)
{
  vnl_vector_fixed<T,3> result;

  result[0] = v1[1] * v2[2] - v1[2] * v2[1];
  result[1] = v1[2] * v2[0] - v1[0] * v2[2];
  result[2] = v1[0] * v2[1] - v1[1] * v2[0];
  return result;
}




template<class T,unsigned int n>
  inline vnl_vector_fixed<T,n> cross_3d( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b ) {
  return cross_3d( a.as_ref(), b);
}




template<class T,unsigned int n>
  inline vnl_vector_fixed<T,n> cross_3d( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b ) {
  return cross_3d( a, b.as_ref());
}



template<class T, unsigned n>
inline T dot_product( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  return dot_product( a.as_ref(), b.as_ref() );
}




template<class T, unsigned n>
inline T dot_product( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  return dot_product( a.as_ref(), b );
}




template<class T, unsigned n>
inline T dot_product( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  return dot_product( a, b.as_ref() );
}



template<class T, unsigned int n>
inline vnl_matrix<T> outer_product( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  return outer_product( a.as_ref(), b.as_ref());
}




template<class T, unsigned int n>
inline vnl_matrix<T> outer_product( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  return outer_product( a, b.as_ref());
}




template<class T, unsigned int n>
inline vnl_matrix<T> outer_product( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  return outer_product( a.as_ref(), b);
}



template<class T, unsigned n>
inline T angle( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  return angle( a.as_ref(), b.as_ref() );
}




template<class T, unsigned n>
inline T angle( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  return angle( a.as_ref(), b );
}




template<class T, unsigned n>
inline T angle( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  return angle( a, b.as_ref() );
}




template<class T, unsigned n>
inline T vnl_vector_ssd( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  return vnl_vector_ssd( a.as_ref(), b.as_ref() );
}




template<class T, unsigned n>
inline T vnl_vector_ssd( const vnl_vector_fixed<T,n>& a, const vnl_vector<T>& b )
{
  return vnl_vector_ssd( a.as_ref(), b );
}




template<class T, unsigned n>
inline T vnl_vector_ssd( const vnl_vector<T>& a, const vnl_vector_fixed<T,n>& b )
{
  return vnl_vector_ssd( a, b.as_ref() );
}




template<class T, unsigned int n>
inline bool operator==( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  return a.operator_eq(b);
}




template<class T, unsigned int n>
inline bool operator==( vnl_vector_fixed<T,n> const& a, vnl_vector<T> const& b )
{
  return a.operator_eq(b);
}




template<class T, unsigned int n>
inline bool operator==( vnl_vector<T> const& a, vnl_vector_fixed<T,n> const& b )
{
  return b.operator_eq(a);
}



template<class T, unsigned int n>
inline bool operator!=( const vnl_vector_fixed<T,n>& a, const vnl_vector_fixed<T,n>& b )
{
  return ! a.operator_eq(b);
}




template<class T, unsigned int n>
inline bool operator!=( vnl_vector_fixed<T,n> const& a, vnl_vector<T> const& b )
{
  return ! a.operator_eq(b);
}




template<class T, unsigned int n>
inline bool operator!=( vnl_vector<T> const& a, vnl_vector_fixed<T,n> const& b )
{
  return ! b.operator_eq(a);
}







template<class T, unsigned int n>
inline
std :: ostream& operator<< ( std :: ostream& ostr, const vnl_vector_fixed<T,n>& v )
{
  v.print( ostr );
  return ostr;
}



template<class T, unsigned int n>
inline
std :: istream& operator>> ( std :: istream& ostr, vnl_vector_fixed<T,n>& v )
{
  v.read_ascii( ostr );
  return ostr;
}
# 33 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h" 2
# 77 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h"
template <class T, unsigned int num_rows, unsigned int num_cols>
class vnl_matrix_fixed;
template <class T, unsigned M, unsigned N>
inline
vnl_vector_fixed<T, M> vnl_matrix_fixed_mat_vec_mult(const vnl_matrix_fixed<T, M, N>& a, const vnl_vector_fixed<T, N>& b);
template <class T, unsigned M, unsigned N, unsigned O>
inline
vnl_matrix_fixed<T, M, O> vnl_matrix_fixed_mat_mat_mult(const vnl_matrix_fixed<T, M, N>& a, const vnl_matrix_fixed<T, N, O>& b);







#define VNL_MATRIX_FIXED_VCL60_WORKAROUND 
# 104 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h"
template <class T, unsigned int num_rows, unsigned int num_cols>
class vnl_matrix_fixed
{
 public:
  typedef unsigned int size_type;

 private:
  T data_[num_rows][num_cols];

 public:


  vnl_matrix_fixed() {}


  explicit vnl_matrix_fixed(T value)
  {
    T* p = data_[0];
    unsigned int n = num_rows * num_cols;
    while (n--)
      *p++ = value;
  }


  explicit vnl_matrix_fixed(const T* datablck)
  {
    std :: memcpy(data_[0], datablck, num_rows*num_cols*sizeof(T));
  }



  vnl_matrix_fixed(const vnl_matrix_fixed& rhs)
  {
    std :: memcpy(data_[0], rhs.data_block(), num_rows*num_cols*sizeof(T));
  }



  vnl_matrix_fixed(const vnl_matrix<T>& rhs)
  {
    (static_cast<void> (__builtin_expect (!!(rhs.rows() == num_rows && rhs.columns() == num_cols), 1) ? 0 : (__assert_fail ("rhs.rows() == num_rows && rhs.columns() == num_cols", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 144, __PRETTY_FUNCTION__), 0)));
    std :: memcpy(data_[0], rhs.data_block(), num_rows*num_cols*sizeof(T));
  }





  ~vnl_matrix_fixed() {}



  vnl_matrix_fixed& operator= (T const&v) { fill(v); return *this; }



  vnl_matrix_fixed& operator=(const vnl_matrix<T>& rhs)
  {
    (static_cast<void> (__builtin_expect (!!(rhs.rows() == num_rows && rhs.columns() == num_cols), 1) ? 0 : (__assert_fail ("rhs.rows() == num_rows && rhs.columns() == num_cols", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 162, __PRETTY_FUNCTION__), 0)));
    std :: memcpy(data_[0], rhs.data_block(), num_rows*num_cols*sizeof(T));
    return *this;
  }


  vnl_matrix_fixed& operator=(const vnl_matrix_fixed& rhs)
  {
    std :: memcpy(data_[0], rhs.data_block(), num_rows*num_cols*sizeof(T));
    return *this;
  }




  unsigned rows () const { return num_rows; }



  unsigned columns () const { return num_cols; }



  unsigned cols () const { return num_cols; }



  unsigned size () const { return rows()*cols(); }


  void put (unsigned r, unsigned c, T const& v) { (*this)(r,c) = v; }


  T get (unsigned r, unsigned c) const { return (*this)(r,c); }



  T * operator[] (unsigned r) { return data_[r]; }



  T const * operator[] (unsigned r) const { return data_[r]; }



  T & operator() (unsigned r, unsigned c)
  {

    (static_cast<void> (__builtin_expect (!!(r<rows()), 1) ? 0 : (__assert_fail ("r<rows()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 210, __PRETTY_FUNCTION__), 0)));
    (static_cast<void> (__builtin_expect (!!(c<cols()), 1) ? 0 : (__assert_fail ("c<cols()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 211, __PRETTY_FUNCTION__), 0)));

    return this->data_[r][c];
  }



  T const & operator() (unsigned r, unsigned c) const
  {

    (static_cast<void> (__builtin_expect (!!(r<rows()), 1) ? 0 : (__assert_fail ("r<rows()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 221, __PRETTY_FUNCTION__), 0)));
    (static_cast<void> (__builtin_expect (!!(c<cols()), 1) ? 0 : (__assert_fail ("c<cols()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 222, __PRETTY_FUNCTION__), 0)));

    return this->data_[r][c];
  }





  void fill (T);



  void fill_diagonal (T);



  void copy_in(T const *);



  void set(T const *d) { copy_in(d); }





  void copy_out(T *) const;


  void inplace_transpose();







  vnl_matrix_fixed& operator+= (T s)
  {
    add( data_block(), s, data_block() ); return *this;
  }


  vnl_matrix_fixed& operator-= (T s)
  {
    sub( data_block(), s, data_block() ); return *this;
  }


  vnl_matrix_fixed& operator*= (T s)
  {
    mul( data_block(), s, data_block() ); return *this;
  }


  vnl_matrix_fixed& operator/= (T s)
  {
    div( data_block(), s, data_block() ); return *this;
  }


  vnl_matrix_fixed& operator+= (vnl_matrix_fixed const& m)
  {
    add( data_block(), m.data_block(), data_block() ); return *this;
  }


  vnl_matrix_fixed& operator+= (vnl_matrix<T> const& m)
  {
    (static_cast<void> (__builtin_expect (!!(m.rows() == rows() && m.cols() == cols()), 1) ? 0 : (__assert_fail ("m.rows() == rows() && m.cols() == cols()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 292, __PRETTY_FUNCTION__), 0)));
    add( data_block(), m.data_block(), data_block() ); return *this;
  }


  vnl_matrix_fixed& operator-= (vnl_matrix_fixed const& m)
  {
    sub( data_block(), m.data_block(), data_block() ); return *this;
  }


  vnl_matrix_fixed& operator-= (vnl_matrix<T> const& m)
  {
    (static_cast<void> (__builtin_expect (!!(m.rows() == rows() && m.cols() == cols()), 1) ? 0 : (__assert_fail ("m.rows() == rows() && m.cols() == cols()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h", 305, __PRETTY_FUNCTION__), 0)));
    sub( data_block(), m.data_block(), data_block() ); return *this;
  }


  vnl_matrix_fixed operator- () const
  {
    vnl_matrix_fixed r;
    sub( T(0), data_block(), r.data_block() );
    return r;
  }


  vnl_matrix_fixed& operator*= (vnl_matrix_fixed<T,num_cols,num_cols> const& s)
  {
    vnl_matrix_fixed<T, num_rows, num_cols> out;
    if (false) { } else for (unsigned i = 0; i < num_rows; ++i)
      if (false) { } else for (unsigned j = 0; j < num_cols; ++j)
      {
        T accum = this->data_[i][0] * s(0,j);
        if (false) { } else for (unsigned k = 1; k < num_cols; ++k)
          accum += this->data_[i][k] * s(k,j);
        out(i,j) = accum;
      }
    return *this = out;
  }
# 348 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h"
  vnl_matrix_fixed apply(T (*f)(T)) const;


  vnl_matrix_fixed apply(T (*f)(T const&)) const;


  vnl_matrix_fixed<T,num_cols,num_rows> transpose () const;


  vnl_matrix_fixed<T,num_cols,num_rows> conjugate_transpose () const;


  vnl_matrix_fixed& update (vnl_matrix<T> const&, unsigned top=0, unsigned left=0);


  void set_column(unsigned i, T const * v);


  void set_column(unsigned i, T value );


  void set_column(unsigned j, vnl_vector<T> const& v);


  void set_columns(unsigned starting_column, vnl_matrix<T> const& M);


  void set_row (unsigned i, T const * v);


  void set_row (unsigned i, T value );


  void set_row (unsigned i, vnl_vector<T> const&);



  vnl_matrix<T> extract (unsigned rows, unsigned cols,
                         unsigned top=0, unsigned left=0) const;


  vnl_vector<T> get_row (unsigned row) const;


  vnl_vector<T> get_column(unsigned col) const;


  vnl_matrix<T> get_n_rows (unsigned rowstart, unsigned n) const;


  vnl_matrix<T> get_n_columns(unsigned colstart, unsigned n) const;






  void set_identity();


  void flipud();


  void fliplr();



  void normalize_rows();



  void normalize_columns();


  void scale_row (unsigned row, T value);


  void scale_column(unsigned col, T value);


  typedef typename vnl_c_vector<T>::abs_t abs_t;


  abs_t array_one_norm() const { return vnl_c_vector<T>::one_norm(begin(), size()); }


  abs_t array_two_norm() const { return vnl_c_vector<T>::two_norm(begin(), size()); }


  abs_t array_inf_norm() const { return vnl_c_vector<T>::inf_norm(begin(), size()); }


  abs_t absolute_value_sum() const { return array_one_norm(); }


  abs_t absolute_value_max() const { return array_inf_norm(); }


  abs_t operator_one_norm() const;


  abs_t operator_inf_norm() const;


  abs_t frobenius_norm() const { return vnl_c_vector<T>::two_norm(begin(), size()); }


  abs_t fro_norm() const { return frobenius_norm(); }


  abs_t rms() const { return vnl_c_vector<T>::rms_norm(begin(), size()); }


  T min_value() const { return vnl_c_vector<T>::min_value(begin(), size()); }


  T max_value() const { return vnl_c_vector<T>::max_value(begin(), size()); }


  T mean() const { return vnl_c_vector<T>::mean(begin(), num_rows*num_cols ); }





  bool empty() const { return num_rows==0 && num_cols==0; }


  bool is_identity() const;


  bool is_identity(double tol) const;


  bool is_zero() const;


  bool is_zero(double tol) const;


  bool is_finite() const;


  bool has_nans() const;



  void assert_size(unsigned rows, unsigned cols) const
  {

    assert_size_internal(rows, cols);

  }


  void assert_finite() const
  {

    assert_finite_internal();

  }




  bool read_ascii(std :: istream& s);





  T const* data_block () const { return data_[0]; }



  T * data_block () { return data_[0]; }
# 539 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h"
  vnl_matrix_ref<T> as_ref() { return vnl_matrix_ref<T>( num_rows, num_cols, data_block() ); }






  const vnl_matrix_ref<T> as_ref() const { return vnl_matrix_ref<T>( num_rows, num_cols, const_cast<T*>(data_block()) ); }





  operator const vnl_matrix_ref<T>() const { return vnl_matrix_ref<T>( num_rows, num_cols, const_cast<T*>(data_block()) ); }


  const vnl_matrix<T> as_matrix() const { return vnl_matrix<T>(const_cast<T*>(data_block()),num_rows,num_cols); }



  typedef T element_type;


  typedef T *iterator;

  iterator begin() { return data_[0]; }

  iterator end() { return begin() + size(); }


  typedef T const *const_iterator;

  const_iterator begin() const { return data_[0]; }

  const_iterator end() const { return begin() + size(); }




  bool operator_eq (vnl_matrix_fixed const & rhs) const
  {
    return equal( this->data_block(), rhs.data_block() );
  }


  bool operator==(vnl_matrix<T> const &that) const { return this->operator_eq(that); }


  bool operator!=(vnl_matrix<T> const &that) const { return !this->operator_eq(that); }


  void print(std :: ostream& os) const;
# 599 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h"
  static void add( const T* a, const T* b, T* r );
  static void add( const T* a, T b, T* r );
  static void sub( const T* a, const T* b, T* r );
  static void sub( const T* a, T b, T* r );
  static void sub( T a, const T* b, T* r );
  static void mul( const T* a, const T* b, T* r );
  static void mul( const T* a, T b, T* r );
  static void div( const T* a, const T* b, T* r );
  static void div( const T* a, T b, T* r );

  static bool equal( const T* a, const T* b );

 private:
  void assert_finite_internal() const;

  void assert_size_internal(unsigned, unsigned) const;
};

#undef VNL_MATRIX_FIXED_VCL60_WORKAROUND
# 626 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_matrix_fixed.h"
template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator+( const vnl_matrix_fixed<T,m,n>& mat1, const vnl_matrix_fixed<T,m,n>& mat2 )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::add( mat1.data_block(), mat2.data_block(), r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator+( const vnl_matrix_fixed<T,m,n>& mat, T s )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::add( mat.data_block(), s, r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator+( T s, const vnl_matrix_fixed<T,m,n>& mat )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::add( mat.data_block(), s, r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator-( const vnl_matrix_fixed<T,m,n>& mat1, const vnl_matrix_fixed<T,m,n>& mat2 )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::sub( mat1.data_block(), mat2.data_block(), r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator-( const vnl_matrix_fixed<T,m,n>& mat, T s )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::sub( mat.data_block(), s, r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator-( T s, const vnl_matrix_fixed<T,m,n>& mat )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::sub( s, mat.data_block(), r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator*( const vnl_matrix_fixed<T,m,n>& mat, T s )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::mul( mat.data_block(), s, r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator*( T s, const vnl_matrix_fixed<T,m,n>& mat )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::mul( mat.data_block(), s, r.data_block() );
  return r;
}

template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> operator/( const vnl_matrix_fixed<T,m,n>& mat, T s )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::div( mat.data_block(), s, r.data_block() );
  return r;
}


template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> element_product( const vnl_matrix_fixed<T,m,n>& mat1,
                                         const vnl_matrix_fixed<T,m,n>& mat2 )
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::mul( mat1.data_block(), mat2.data_block(), r.data_block() );
  return r;
}


template <class T, unsigned m, unsigned n>
inline
vnl_matrix_fixed<T,m,n> element_quotient( const vnl_matrix_fixed<T,m,n>& mat1,
                                          const vnl_matrix_fixed<T,m,n>& mat2)
{
  vnl_matrix_fixed<T,m,n> r;
  vnl_matrix_fixed<T,m,n>::div( mat1.data_block(), mat2.data_block(), r.data_block() );
  return r;
}





template <class T, unsigned M, unsigned N>
inline
vnl_vector_fixed<T, M>
vnl_matrix_fixed_mat_vec_mult(const vnl_matrix_fixed<T, M, N>& a,
                              const vnl_vector_fixed<T, N>& b)
{
  vnl_vector_fixed<T, M> out;
  if (false) { } else for (unsigned i = 0; i < M; ++i)
  {
    T accum = a(i,0) * b(0);
    if (false) { } else for (unsigned k = 1; k < N; ++k)
      accum += a(i,k) * b(k);
    out(i) = accum;
  }
  return out;
}


template <class T, unsigned M, unsigned N, unsigned O>
inline
vnl_matrix_fixed<T, M, O>
vnl_matrix_fixed_mat_mat_mult(const vnl_matrix_fixed<T, M, N>& a,
                              const vnl_matrix_fixed<T, N, O>& b)
{
  vnl_matrix_fixed<T, M, O> out;
  if (false) { } else for (unsigned i = 0; i < M; ++i)
    if (false) { } else for (unsigned j = 0; j < O; ++j)
    {
      T accum = a(i,0) * b(0,j);
      if (false) { } else for (unsigned k = 1; k < N; ++k)
        accum += a(i,k) * b(k,j);
      out(i,j) = accum;
    }
  return out;
}







template <class T, unsigned M, unsigned N>
inline
vnl_vector_fixed<T, M> operator*(const vnl_matrix_fixed<T, M, N>& a, const vnl_vector_fixed<T, N>& b)
{
  return vnl_matrix_fixed_mat_vec_mult(a,b);
}



template <class T, unsigned M, unsigned N, unsigned O>
inline
vnl_matrix_fixed<T, M, O> operator*(const vnl_matrix_fixed<T, M, N>& a, const vnl_matrix_fixed<T, N, O>& b)
{
  return vnl_matrix_fixed_mat_mat_mult(a,b);
}







template <class T, unsigned m, unsigned n>
inline vnl_matrix<T> operator+( const vnl_matrix_fixed<T,m,n>& a, const vnl_matrix<T>& b )
{
  return a.as_ref() + b;
}

template <class T, unsigned m, unsigned n>
inline vnl_matrix<T> operator+( const vnl_matrix<T>& a, const vnl_matrix_fixed<T,m,n>& b )
{
  return a + b.as_ref();
}

template <class T, unsigned m, unsigned n>
inline vnl_matrix<T> operator-( const vnl_matrix_fixed<T,m,n>& a, const vnl_matrix<T>& b )
{
  return a.as_ref() - b;
}

template <class T, unsigned m, unsigned n>
inline vnl_matrix<T> operator-( const vnl_matrix<T>& a, const vnl_matrix_fixed<T,m,n>& b )
{
  return a - b.as_ref();
}

template <class T, unsigned m, unsigned n>
inline vnl_matrix<T> operator*( const vnl_matrix_fixed<T,m,n>& a, const vnl_matrix<T>& b )
{
  return a.as_ref() * b;
}

template <class T, unsigned m, unsigned n>
inline vnl_matrix<T> operator*( const vnl_matrix<T>& a, const vnl_matrix_fixed<T,m,n>& b )
{
  return a * b.as_ref();
}

template <class T, unsigned m, unsigned n>
inline vnl_vector<T> operator*( const vnl_matrix_fixed<T,m,n>& a, const vnl_vector<T>& b )
{
  return a.as_ref() * b;
}

template <class T, unsigned n>
inline vnl_vector<T> operator*( const vnl_matrix<T>& a, const vnl_vector_fixed<T,n>& b )
{
  return a * b.as_ref();
}




template <class T, unsigned m, unsigned n>
inline
std :: ostream& operator<< (std :: ostream& os, vnl_matrix_fixed<T,m,n> const& mat)
{
  mat.print(os);
  return os;
}

template <class T, unsigned m, unsigned n>
inline
std :: istream& operator>> (std :: istream& is, vnl_matrix_fixed<T,m,n>& mat)
{
  mat.read_ascii(is);
  return is;
}


#define VNL_MATRIX_FIXED_PAIR_INSTANTIATE(T,M,N,O) extern "please include vnl/vnl_matrix_fixed.txx instead"
# 25 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.h" 2


namespace itk
{
# 38 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.h"
template<class T, unsigned int NRows=3, unsigned int NColumns=3>
class Matrix {
public:

  typedef Matrix Self;


  typedef T ValueType;
  typedef T ComponentType;


  static const unsigned int RowDimensions = NRows;
  static const unsigned int ColumnDimensions = NColumns;


  typedef vnl_matrix_fixed<T,NRows,NColumns> InternalMatrixType;


  Vector<T,NRows> operator*(const Vector<T,NColumns> & vector) const;


  Point<T,NRows> operator*(const Point<T,NColumns> & vector) const;


  CovariantVector<T,NRows>
  operator*(const CovariantVector<T,NColumns> & vector) const;


  Self operator*(const Self & matrix) const;


  Self operator+(const Self & matrix) const;
  const Self & operator+=(const Self & matrix );


  Self operator-(const Self & matrix) const;
  const Self & operator-=(const Self & matrix );


  vnl_matrix<T> operator*(const vnl_matrix<T> & matrix) const;


  void operator*=(const Self & matrix);


  void operator*=(const vnl_matrix<T> & matrix);


  vnl_vector<T> operator*(const vnl_vector<T> & matrix) const;


  void operator*=(const T & value)
    { m_Matrix *= value; }


  Self operator*(const T & value)
    { Self result( *this );
      result *= value;
      return result; }


  inline T * operator[]( unsigned int i )
    { return m_Matrix[i]; }


  inline const T * operator[]( unsigned int i ) const
    { return m_Matrix[i]; }


  inline InternalMatrixType & GetVnlMatrix( void )
    { return m_Matrix; }


  inline const InternalMatrixType & GetVnlMatrix( void ) const
    { return m_Matrix; }


  inline void SetIdentity( void )
    { m_Matrix.set_identity(); }


  inline void Fill( const T & value )
    { m_Matrix.fill( value ); }


  inline const Self & operator=( const vnl_matrix<T> & matrix);


  inline const Self & operator=( const Self & matrix);


  inline vnl_matrix_fixed<T,NColumns,NRows> GetInverse( void ) const;


  inline vnl_matrix_fixed<T,NColumns,NRows> GetTranspose( void ) const;


  Matrix() : m_Matrix(NumericTraits<T>::Zero) {};


  Matrix(const Self & matrix) : m_Matrix( matrix.m_Matrix ) {};

private:
  InternalMatrixType m_Matrix;

};

template< class T, unsigned int NRows, unsigned int NColumns >
 std::ostream& operator<<(std::ostream& os,
                                    const Matrix<T,NRows,NColumns> & v)
                            { os << v.GetVnlMatrix(); return os; }



}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.txx"
#define _itkMatrix_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.txx" 2

# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_matrix_inverse.h" 1


#define vnl_matrix_inverse_h_ 
# 18 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_matrix_inverse.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_svd.h" 1


#define vnl_svd_h_ 
# 24 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_svd.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h" 1


#define vnl_diag_matrix_h_ 
# 20 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_cassert.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h" 2
# 31 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h"

template <class T>
class vnl_diag_matrix
{
  vnl_vector<T> diagonal_;

 public:
  vnl_diag_matrix() {}


  vnl_diag_matrix(unsigned nn) : diagonal_(nn) {}


  vnl_diag_matrix(unsigned nn, T const& value) : diagonal_(nn, value) {}



  vnl_diag_matrix(vnl_vector<T> const& that): diagonal_(that) {}
 ~vnl_diag_matrix() {}

  inline vnl_diag_matrix& operator=(vnl_diag_matrix<T> const& that) {
    this->diagonal_ = that.diagonal_;
    return *this;
  }




  inline vnl_diag_matrix<T>& operator*=(T v) { diagonal_ *= v; return *this; }

  inline vnl_diag_matrix<T>& operator/=(T v) { diagonal_ /= v; return *this; }



  void invert_in_place();
  T determinant() const;
  vnl_vector<T> solve(vnl_vector<T> const& b);
  void solve(vnl_vector<T> const& b, vnl_vector<T>* out);



  inline T operator () (unsigned i, unsigned j) const {
    return (i != j) ? T(0) : diagonal_[i];
  }

  inline T& operator () (unsigned i, unsigned j) {
    (static_cast<void> (__builtin_expect (!!(i == j), 1) ? 0 : (__assert_fail ("i == j", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 77, __PRETTY_FUNCTION__), 0)));
    return diagonal_[i];
  }
  inline T& operator() (unsigned i) { return diagonal_[i]; }
  inline T const& operator() (unsigned i) const { return diagonal_[i]; }

  inline T& operator[] (unsigned i) { return diagonal_[i]; }
  inline T const& operator[] (unsigned i) const { return diagonal_[i]; }


  inline void put (unsigned r, unsigned c, T const& v) {
    (static_cast<void> (__builtin_expect (!!(r == c), 1) ? 0 : (__assert_fail ("r == c", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 88, __PRETTY_FUNCTION__), 0))); (static_cast<void> (__builtin_expect (!!(r<size()), 1) ? 0 : (__assert_fail ("r<size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 88, __PRETTY_FUNCTION__), 0))); diagonal_[r] = v;
  }


  inline T get (unsigned r, unsigned c) const {
    (static_cast<void> (__builtin_expect (!!(r == c), 1) ? 0 : (__assert_fail ("r == c", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 93, __PRETTY_FUNCTION__), 0))); (static_cast<void> (__builtin_expect (!!(r<size()), 1) ? 0 : (__assert_fail ("r<size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 93, __PRETTY_FUNCTION__), 0))); return diagonal_[r];
  }


  inline void fill_diagonal (T const& v) { diagonal_.fill(v); }



  typedef typename vnl_vector<T>::iterator iterator;
  inline iterator begin() { return diagonal_.begin(); }
  inline iterator end() { return diagonal_.end(); }
  typedef typename vnl_vector<T>::const_iterator const_iterator;
  inline const_iterator begin() const { return diagonal_.begin(); }
  inline const_iterator end() const { return diagonal_.end(); }

  inline unsigned size() const { return diagonal_.size(); }
  inline unsigned rows() const { return diagonal_.size(); }
  inline unsigned cols() const { return diagonal_.size(); }
  inline unsigned columns() const { return diagonal_.size(); }


  inline vnl_matrix<T> asMatrix() const;

  inline vnl_matrix<T> as_ref() const { return asMatrix(); }


  inline operator vnl_matrix<T> () const { return asMatrix(); }

  inline void set_size(int n) { diagonal_.set_size(n); }
 private:

  inline void resize(int n) { set_size(n); }
 public:
  inline void clear() { diagonal_.clear(); }
  inline void fill(T const &x) { diagonal_.fill(x); }


  inline T* data_block() { return diagonal_.data_block(); }
  inline T const* data_block() const { return diagonal_.data_block(); }


  inline vnl_vector<T> const& diagonal() const { return diagonal_; }


  inline void set(vnl_vector<T> const& v) { diagonal_=v; }

 private:



};



template <class T>
std :: ostream& operator<< (std :: ostream&, vnl_diag_matrix<T> const&);


template <class T>
inline vnl_matrix<T> vnl_diag_matrix<T>::asMatrix() const
{
  unsigned len = diagonal_.size();
  vnl_matrix<T> ret(len, len);
  if (false) { } else for (unsigned i = 0; i < len; ++i)
  {
    unsigned j;
    if (false) { } else for (j = 0; j < i; ++j)
      ret(i,j) = T(0);
    if (false) { } else for (j = i+1; j < len; ++j)
      ret(i,j) = T(0);
    ret(i,i) = diagonal_[i];
  }
  return ret;
}



template <class T>
inline void vnl_diag_matrix<T>::invert_in_place()
{
  unsigned len = diagonal_.size();
  T* d = data_block();
  T one = T(1);
  if (false) { } else for (unsigned i = 0; i < len; ++i)
    d[i] = one / d[i];
}


template <class T>
inline T vnl_diag_matrix<T>::determinant() const
{
  T det = T(1);
  T const* d = data_block();
  unsigned len = diagonal_.size();
  if (false) { } else for (unsigned i = 0; i < len; ++i)
    det *= d[i];
  return det;
}



template <class T>
inline vnl_diag_matrix<T> operator* (vnl_diag_matrix<T> const& A, vnl_diag_matrix<T> const& B)
{
  (static_cast<void> (__builtin_expect (!!(A.size() == B.size()), 1) ? 0 : (__assert_fail ("A.size() == B.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 197, __PRETTY_FUNCTION__), 0)));
  vnl_diag_matrix<T> ret = A;
  if (false) { } else for (unsigned i = 0; i < A.size(); ++i)
    ret(i,i) *= B(i,i);
  return ret;
}




template <class T>
inline vnl_matrix<T> operator* (vnl_matrix<T> const& A, vnl_diag_matrix<T> const& D)
{
  (static_cast<void> (__builtin_expect (!!(A.columns() == D.size()), 1) ? 0 : (__assert_fail ("A.columns() == D.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 210, __PRETTY_FUNCTION__), 0)));
  vnl_matrix<T> ret(A.rows(), A.columns());
  if (false) { } else for (unsigned i = 0; i < A.rows(); ++i)
    if (false) { } else for (unsigned j = 0; j < A.columns(); ++j)
      ret(i,j) = A(i,j) * D(j,j);
  return ret;
}




template <class T>
inline vnl_matrix<T> operator* (vnl_diag_matrix<T> const& D, vnl_matrix<T> const& A)
{
  (static_cast<void> (__builtin_expect (!!(A.rows() == D.size()), 1) ? 0 : (__assert_fail ("A.rows() == D.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 224, __PRETTY_FUNCTION__), 0)));
  vnl_matrix<T> ret(A.rows(), A.columns());
  T const* d = D.data_block();
  if (false) { } else for (unsigned i = 0; i < A.rows(); ++i)
    if (false) { } else for (unsigned j = 0; j < A.columns(); ++j)
      ret(i,j) = A(i,j) * d[i];
  return ret;
}



template <class T>
inline vnl_diag_matrix<T> operator+ (vnl_diag_matrix<T> const& A, vnl_diag_matrix<T> const& B)
{
  (static_cast<void> (__builtin_expect (!!(A.size() == B.size()), 1) ? 0 : (__assert_fail ("A.size() == B.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 238, __PRETTY_FUNCTION__), 0)));
  vnl_diag_matrix<T> ret = A;
  if (false) { } else for (unsigned i = 0; i < A.size(); ++i)
    ret(i,i) += B(i,i);
  return ret;
}




template <class T>
inline vnl_matrix<T> operator+ (vnl_matrix<T> const& A, vnl_diag_matrix<T> const& D)
{
  const unsigned n = D.size();
  (static_cast<void> (__builtin_expect (!!(A.rows() == n), 1) ? 0 : (__assert_fail ("A.rows() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 252, __PRETTY_FUNCTION__), 0))); (static_cast<void> (__builtin_expect (!!(A.columns() == n), 1) ? 0 : (__assert_fail ("A.columns() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 252, __PRETTY_FUNCTION__), 0)));
  vnl_matrix<T> ret(A);
  T const* d = D.data_block();
  if (false) { } else for (unsigned j = 0; j < n; ++j)
    ret(j,j) += d[j];
  return ret;
}




template <class T>
inline vnl_matrix<T> operator+ (vnl_diag_matrix<T> const& D, vnl_matrix<T> const& A)
{
  return A + D;
}



template <class T>
inline vnl_diag_matrix<T> operator- (vnl_diag_matrix<T> const& A, vnl_diag_matrix<T> const& B)
{
  (static_cast<void> (__builtin_expect (!!(A.size() == B.size()), 1) ? 0 : (__assert_fail ("A.size() == B.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 274, __PRETTY_FUNCTION__), 0)));
  vnl_diag_matrix<T> ret = A;
  if (false) { } else for (unsigned i = 0; i < A.size(); ++i)
    ret(i,i) -= B(i,i);
  return ret;
}




template <class T>
inline vnl_matrix<T> operator- (vnl_matrix<T> const& A, vnl_diag_matrix<T> const& D)
{
  const unsigned n = D.size();
  (static_cast<void> (__builtin_expect (!!(A.rows() == n), 1) ? 0 : (__assert_fail ("A.rows() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 288, __PRETTY_FUNCTION__), 0))); (static_cast<void> (__builtin_expect (!!(A.columns() == n), 1) ? 0 : (__assert_fail ("A.columns() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 288, __PRETTY_FUNCTION__), 0)));
  vnl_matrix<T> ret(A);
  T const* d = D.data_block();
  if (false) { } else for (unsigned j = 0; j < n; ++j)
    ret(j,j) -= d[j];
  return ret;
}




template <class T>
inline vnl_matrix<T> operator- (vnl_diag_matrix<T> const& D, vnl_matrix<T> const& A)
{
  const unsigned n = D.size();
  (static_cast<void> (__builtin_expect (!!(A.rows() == n), 1) ? 0 : (__assert_fail ("A.rows() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 303, __PRETTY_FUNCTION__), 0))); (static_cast<void> (__builtin_expect (!!(A.columns() == n), 1) ? 0 : (__assert_fail ("A.columns() == n", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 303, __PRETTY_FUNCTION__), 0)));
  vnl_matrix<T> ret(n, n);
  T const* d = D.data_block();
  if (false) { } else for (unsigned i = 0; i < n; ++i)
  {
    if (false) { } else for (unsigned j = 0; j < i; ++j)
      ret(i,j) = -A(i,j);
    if (false) { } else for (unsigned j = i+1; j < n; ++j)
      ret(i,j) = -A(i,j);
    ret(i,i) = d[i] - A(i,i);
  }
  return ret;
}




template <class T>
inline vnl_vector<T> operator* (vnl_diag_matrix<T> const& D, vnl_vector<T> const& A)
{
  (static_cast<void> (__builtin_expect (!!(A.size() == D.size()), 1) ? 0 : (__assert_fail ("A.size() == D.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 323, __PRETTY_FUNCTION__), 0)));
  return element_product(D.diagonal(), A);
}




template <class T>
inline vnl_vector<T> operator* (vnl_vector<T> const& A, vnl_diag_matrix<T> const& D)
{
  (static_cast<void> (__builtin_expect (!!(A.size() == D.size()), 1) ? 0 : (__assert_fail ("A.size() == D.size()", "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_diag_matrix.h", 333, __PRETTY_FUNCTION__), 0)));
  return element_product(D.diagonal(), A);
}
# 25 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_svd.h" 2
# 61 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_svd.h"
 template <class T>
class vnl_svd
{
 public:

  typedef typename vnl_numeric_traits<T>::abs_t singval_t;
# 83 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_svd.h"
  vnl_svd(vnl_matrix<T> const &M, double zero_out_tol = 0.0);
 ~vnl_svd() {}




  void zero_out_absolute(double tol = 1e-8);


  void zero_out_relative(double tol = 1e-8);
  int singularities () const { return W_.rows() - rank(); }
  int rank () const { return rank_; }
  singval_t well_condition () const { return sigma_min()/sigma_max(); }


  singval_t determinant_magnitude () const;
  singval_t norm() const;


  vnl_matrix<T> & U() { return U_; }


  vnl_matrix<T> const& U() const { return U_; }


  T U(int i, int j) { return U_(i,j); }


  vnl_diag_matrix<singval_t> & W() { return W_; }


  vnl_diag_matrix<singval_t> const & W() const { return W_; }
  vnl_diag_matrix<singval_t> & Winverse() { return Winverse_; }
  vnl_diag_matrix<singval_t> const & Winverse() const { return Winverse_; }
  singval_t & W(int i, int j) { return W_(i,j); }
  singval_t & W(int i) { return W_(i,i); }
  singval_t sigma_max() const { return W_(0,0); }
  singval_t sigma_min() const { return W_(n_-1,n_-1); }


  vnl_matrix<T> & V() { return V_; }


  vnl_matrix<T> const& V() const { return V_; }


  T V(int i, int j) { return V_(i,j); }


  inline vnl_matrix<T> inverse () const { return pinverse(); }


  vnl_matrix<T> pinverse (unsigned int rank = -1) const;


  vnl_matrix<T> tinverse (unsigned int rank = -1) const;


  vnl_matrix<T> recompose (unsigned int rank = -1) const;


  vnl_matrix<T> solve (vnl_matrix<T> const& B) const;


  vnl_vector<T> solve (vnl_vector<T> const& y) const;
  void solve (T const *rhs, T *lhs) const;



  void solve_preinverted(vnl_vector<T> const& rhs, vnl_vector<T>* out) const;


  vnl_matrix<T> nullspace() const;


  vnl_matrix<T> left_nullspace() const;


  vnl_matrix<T> nullspace(int required_nullspace_dimension) const;


  vnl_matrix<T> left_nullspace(int required_nullspace_dimension) const;




  vnl_vector<T> nullvector() const;



  vnl_vector<T> left_nullvector() const;

  bool valid() const { return valid_; }

 private:

  int m_, n_;
  vnl_matrix<T> U_;
  vnl_diag_matrix<singval_t> W_;
  vnl_diag_matrix<singval_t> Winverse_;
  vnl_matrix<T> V_;
  unsigned rank_;
  bool have_max_;
  singval_t max_;
  bool have_min_;
  singval_t min_;
  double last_tol_;
  bool valid_;


  vnl_svd(vnl_svd<T> const &) { }
  vnl_svd<T>& operator=(vnl_svd<T> const &) { return *this; }
};

template <class T>
inline
vnl_matrix<T> vnl_svd_inverse(vnl_matrix<T> const& m)
{
  return vnl_svd<T>(m).inverse();
}

 template <class T>
std :: ostream& operator<<(std :: ostream&, vnl_svd<T> const& svd);
# 19 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_matrix_inverse.h" 2
# 30 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/algo/vnl_matrix_inverse.h"
template <class T>
struct vnl_matrix_inverse : public vnl_svd<T>
{
  vnl_matrix_inverse(vnl_matrix<T> const & M): vnl_svd<T>(M) { }
  ~vnl_matrix_inverse() {};

  operator vnl_matrix<T> () const { return this->inverse(); }
};

template <class T>
inline
vnl_vector<T> operator*(vnl_matrix_inverse<T> const & i,
                        vnl_vector<T> const & B)
{
  return i.solve(B);
}

template <class T>
inline
vnl_matrix<T> operator*(vnl_matrix_inverse<T> const & i,
                        vnl_matrix<T> const & B)
{
  return i.solve(B);
}
# 23 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.txx" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_transpose.h" 1


#define vnl_transpose_h_ 
# 18 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_transpose.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_iostream.h" 1


#define vcl_iostream_h_ 
# 48 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_iostream.h"
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_iostream.h" 1

#define vcl_iso_iostream_h_ 
# 11 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_iostream.h"
#define vcl_generic_iostream_STD std


# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_iostream.h" 1

#define vcl_generic_iostream_h_ 





#define vcl_cin vcl_generic_iostream_STD :: cin



#define vcl_cout vcl_generic_iostream_STD :: cout



#define vcl_cerr vcl_generic_iostream_STD :: cerr



#define vcl_clog vcl_generic_iostream_STD :: clog
# 34 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_iostream.h"
#define vcl_ios_in vcl_generic_iostream_STD :: ios::in



#define vcl_ios_out vcl_generic_iostream_STD :: ios::out



#define vcl_ios_ate vcl_generic_iostream_STD :: ios::ate



#define vcl_ios_app vcl_generic_iostream_STD :: ios::app



#define vcl_ios_trunc vcl_generic_iostream_STD :: ios::trunc



#define vcl_ios_binary vcl_generic_iostream_STD :: ios::binary



#define vcl_ios_openmode vcl_generic_iostream_STD :: ios::openmode
# 70 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_iostream.h"
#define vcl_endl vcl_generic_iostream_STD :: endl



#define vcl_ends vcl_generic_iostream_STD :: ends



#define vcl_flush vcl_generic_iostream_STD :: flush
# 90 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/generic/vcl_iostream.h"
#define vcl_streamsize vcl_generic_iostream_STD :: streamsize



#define vcl_hex vcl_generic_iostream_STD :: hex



#define vcl_oct vcl_generic_iostream_STD :: oct



#define vcl_dec vcl_generic_iostream_STD :: dec



#define vcl_ws vcl_generic_iostream_STD :: ws



#define vcl_setfill vcl_generic_iostream_STD :: setfill



#define vcl_setprecision vcl_generic_iostream_STD :: setprecision



#define vcl_setw vcl_generic_iostream_STD :: setw



#define vcl_fixed vcl_generic_iostream_STD :: fixed



#define vcl_scientific vcl_generic_iostream_STD :: scientific
# 15 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/iso/vcl_iostream.h" 2
# 49 "/tmp/installed/include/InsightToolkit/Utilities/vxl/vcl/vcl_iostream.h" 2
# 19 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_transpose.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_fastops.h" 1


#define vnl_fastops_h_ 
# 25 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_fastops.h"
class vnl_fastops
{
 public:
  static void AtA(const vnl_matrix<double>& A, vnl_matrix<double>* out);

  static void AB(const vnl_matrix<double>& A, const vnl_matrix<double>& B, vnl_matrix<double>* out);
  static void AtB(const vnl_matrix<double>& A, const vnl_matrix<double>& B, vnl_matrix<double>* out);
  static void AtB(const vnl_matrix<double>& A, const vnl_vector<double>& B, vnl_vector<double>* out);
  static void ABt(const vnl_matrix<double>& A, const vnl_matrix<double>& B, vnl_matrix<double>* out);

  static void inc_X_by_AtB(vnl_matrix<double>& X, const vnl_matrix<double>& A, const vnl_matrix<double>& B);
  static void inc_X_by_AtB(vnl_vector<double>& X, const vnl_matrix<double>& A, const vnl_vector<double>& B);
  static void inc_X_by_AtA(vnl_matrix<double>& X, const vnl_matrix<double>& A);

  static void dec_X_by_AtB(vnl_matrix<double>& X, const vnl_matrix<double>& A, const vnl_matrix<double>& B);
  static void dec_X_by_AtA(vnl_matrix<double>& X, const vnl_matrix<double>& A);

  static void dec_X_by_ABt(vnl_matrix<double>& X, const vnl_matrix<double>& A, const vnl_matrix<double>& B);


  static double dot(const double* a, const double* b, int n);
};
# 20 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_transpose.h" 2
# 35 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_transpose.h"
class vnl_transpose
{
  const vnl_matrix<double>& M_;
 public:


  vnl_transpose(const vnl_matrix<double>& M): M_(M) {}


  operator vnl_matrix<double> () const {
    std :: cerr << "vnl_transpose being converted to matrix -- help! I don't wanna go!\n";
    return M_.transpose();
  }


  vnl_matrix<double> asMatrix () const {
    return M_.transpose();
  }


  vnl_matrix<double> operator* (const vnl_matrix<double>& O) {
    vnl_matrix<double> ret(M_.columns(), O.columns());
    vnl_fastops::AtB(M_, O, &ret);
    return ret;
  }


  vnl_vector<double> operator* (const vnl_vector<double>& O) {
    vnl_vector<double> ret(M_.columns());
    vnl_fastops::AtB(M_, O, &ret);
    return ret;
  }


  friend vnl_matrix<double> operator* (const vnl_matrix<double>& A, const vnl_transpose& B) {
    vnl_matrix<double> ret(A.rows(), B.M_.rows());
    vnl_fastops::ABt(A, B.M_, &ret);
    return ret;
  }
};
# 24 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.txx" 2


namespace itk
{







template<class T, unsigned int NRows, unsigned int NColumns >
Vector<T, NRows>
Matrix<T, NRows, NColumns>
::operator*( const Vector<T, NColumns> & vect ) const
{
  Vector<T,NRows> result;
  if (false) { } else for( unsigned int r=0; r<NRows; r++)
    {
    T sum = NumericTraits<T>::Zero;
    if (false) { } else for( unsigned int c=0; c<NColumns; c++ )
      {
      sum += m_Matrix(r,c) * vect[c];
      }
    result[r] = sum;
    }
  return result;
}







template<class T, unsigned int NRows, unsigned int NColumns >
Point<T, NRows>
Matrix<T, NRows, NColumns>
::operator*( const Point<T, NColumns> & pnt ) const
{
  Point<T,NRows> result;
  if (false) { } else for( unsigned int r=0; r<NRows; r++)
    {
    T sum = NumericTraits<T>::Zero;
    if (false) { } else for( unsigned int c=0; c<NColumns; c++ )
      {
      sum += m_Matrix(r,c) * pnt[c];
      }
    result[r] = sum;
    }
  return result;
}







template<class T, unsigned int NRows, unsigned int NColumns >
CovariantVector<T, NRows>
Matrix<T, NRows, NColumns>
::operator*( const CovariantVector<T, NColumns> & covect ) const
{
  CovariantVector<T,NRows> result;
  if (false) { } else for( unsigned int r=0; r<NRows; r++)
    {
    T sum = NumericTraits<T>::Zero;
    if (false) { } else for( unsigned int c=0; c<NColumns; c++ )
      {
      sum += m_Matrix(r,c) * covect[c];
      }
    result[r] = sum;
    }
  return result;
}






template<class T, unsigned int NRows, unsigned int NColumns >
Matrix<T, NRows, NColumns>
Matrix<T, NRows, NColumns>
::operator*( const Self & matrix ) const
{
  Self result;
  result = m_Matrix * matrix.m_Matrix;
  return result;
}





template<class T, unsigned int NRows, unsigned int NColumns >
Matrix<T, NRows, NColumns>
Matrix<T, NRows, NColumns>
::operator+( const Self & matrix ) const
{
  Self result;
  if (false) { } else for( unsigned int r=0; r<NRows; r++)
    {
    if (false) { } else for( unsigned int c=0; c<NColumns; c++ )
      {
      result.m_Matrix(r,c) = m_Matrix(r,c) + matrix.m_Matrix(r,c);
      }
    }
  return result;
}






template<class T, unsigned int NRows, unsigned int NColumns >
const Matrix<T, NRows, NColumns> &
Matrix<T, NRows, NColumns>
::operator+=( const Self & matrix )
{
  if (false) { } else for( unsigned int r=0; r<NRows; r++)
    {
    if (false) { } else for( unsigned int c=0; c<NColumns; c++ )
      {
      m_Matrix(r,c) += matrix.m_Matrix(r,c);
      }
    }
  return *this;
}







template<class T, unsigned int NRows, unsigned int NColumns >
Matrix<T, NRows, NColumns>
Matrix<T, NRows, NColumns>
::operator-( const Self & matrix ) const
{
  Self result;
  if (false) { } else for( unsigned int r=0; r<NRows; r++)
    {
    if (false) { } else for( unsigned int c=0; c<NColumns; c++ )
      {
      result.m_Matrix(r,c) = m_Matrix(r,c) - matrix.m_Matrix(r,c);
      }
    }
  return result;
}






template<class T, unsigned int NRows, unsigned int NColumns >
const Matrix<T, NRows, NColumns> &
Matrix<T, NRows, NColumns>
::operator-=( const Self & matrix )
{
  if (false) { } else for( unsigned int r=0; r<NRows; r++)
    {
    if (false) { } else for( unsigned int c=0; c<NColumns; c++ )
      {
      m_Matrix(r,c) -= matrix.m_Matrix(r,c);
      }
    }
  return *this;
}
# 205 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.txx"
template<class T, unsigned int NRows, unsigned int NColumns >
vnl_matrix<T>
Matrix<T, NRows, NColumns>
::operator*( const vnl_matrix<T> & matrix ) const
{
  return m_Matrix * matrix;
}






template<class T, unsigned int NRows, unsigned int NColumns >
void
Matrix<T, NRows, NColumns>
::operator*=( const Self & matrix )
{
  m_Matrix *= matrix.m_Matrix;
}





template<class T, unsigned int NRows, unsigned int NColumns >
void
Matrix<T, NRows, NColumns>
::operator*=( const vnl_matrix<T> & matrix )
{
  m_Matrix *= matrix;
}






template<class T, unsigned int NRows, unsigned int NColumns >
vnl_vector<T>
Matrix<T, NRows, NColumns>
::operator*( const vnl_vector<T> & vc ) const
{
  return m_Matrix * vc;
}






template<class T, unsigned int NRows, unsigned int NColumns >
const Matrix<T, NRows, NColumns> &
Matrix<T, NRows, NColumns>
::operator=( const Self & matrix )
{
  m_Matrix = matrix.m_Matrix;
  return *this;
}







template<class T, unsigned int NRows, unsigned int NColumns >
const Matrix<T, NRows, NColumns> &
Matrix<T, NRows, NColumns>
::operator=( const vnl_matrix<T> & matrix )
{
  m_Matrix = matrix;
  return *this;
}





template<class T, unsigned int NRows, unsigned int NColumns >
vnl_matrix_fixed<T,NColumns,NRows>
Matrix<T, NRows, NColumns>
::GetInverse( void ) const
{
  vnl_matrix<T> temp = vnl_matrix_inverse<T>( m_Matrix );
  return temp;
}





template<class T, unsigned int NRows, unsigned int NColumns >
vnl_matrix_fixed<T,NColumns,NRows>
Matrix<T, NRows, NColumns>
::GetTranspose( void ) const
{
  return m_Matrix.transpose();
}



}
# 157 "/tmp/installed/include/InsightToolkit/Common/itkMatrix.h" 2
# 24 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h"
#define __itkTransform_h 






# 1 "/tmp/installed/include/InsightToolkit/Common/itkArray.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkArray.h"
#define __itkArray_h 




namespace itk
{
# 43 "/tmp/installed/include/InsightToolkit/Common/itkArray.h"
template <typename TValueType >
class Array : public vnl_vector< TValueType >
{
public:


  typedef TValueType ValueType;
  typedef Array Self;
  typedef vnl_vector<TValueType> VnlVectorType;

public:



  Array();


  Array(unsigned int dimension);


  void Fill (TValueType const& v) { fill(v); }


  const Self & operator=( const Self &rhs );
  const Self & operator=( const VnlVectorType & rhs );


  unsigned int Size (void ) const
      { return static_cast<unsigned int>( this->size() ); }
  unsigned int GetNumberOfElements(void) const
      { return static_cast<unsigned int>( this->size() ); }


  const TValueType & GetElement( unsigned int i ) const
    { return this->operator[]( i ); }


  void SetElement( unsigned int i, const TValueType & value )
    { this->operator[]( i ) = value; }


  void SetSize(unsigned int sz);
  unsigned int GetSize(void) const
      { return static_cast<unsigned int>( this->size() ); }






  void SetData(TValueType* data,bool LetArrayManageMemory = false);



  ~Array();



private:

  bool m_LetArrayManageMemory;

};



template <typename TValueType >
std::ostream & operator<<(std::ostream &os, const Array<TValueType> &arr)
{
  const unsigned int length = arr.size();
  const signed int last = (unsigned int) length - 1;

  os << "[";
  if (false) { } else for (signed int i=0; i < last; ++i)
    {
    os << arr[i] << ", ";
    }
  if (length >= 1)
    {
    os << arr[last];
    }
  os << "]";
  return os;
}

}




# 1 "/tmp/installed/include/InsightToolkit/Common/itkArray.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkArray.txx"
#define _itkArray_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkArray.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkArray.txx" 2

namespace itk
{


template < typename TValueType >
Array<TValueType >
::Array():vnl_vector<TValueType>()
{
  m_LetArrayManageMemory = true;
}



template < typename TValueType >
Array<TValueType >
::Array(unsigned int dimension):vnl_vector<TValueType>(dimension)
{
  m_LetArrayManageMemory = true;
}


template < typename TValueType >
Array<TValueType >
::~Array()
{
  if(!m_LetArrayManageMemory)
    {
    vnl_vector<TValueType>::data = 0;
    }
}







template < typename TValueType >
void
Array<TValueType >
::SetData(TValueType* data,bool LetArrayManageMemory)
{
  if(m_LetArrayManageMemory)
    {
    vnl_vector<TValueType>::destroy();
    }
  vnl_vector<TValueType>::data = data;
  m_LetArrayManageMemory = LetArrayManageMemory;
}

template < typename TValueType >
void Array<TValueType >
::SetSize(unsigned int sz)
{

  if ( this->size() != sz )
    {



    if(!m_LetArrayManageMemory)
      {
      vnl_vector<TValueType>::data = 0;
      }


    this->set_size(sz);



    m_LetArrayManageMemory = true;

    }

}



template < typename TValueType >
const typename Array<TValueType>
::Self&
Array<TValueType>
::operator=( const Self& rhs )
{

  if( this == &rhs ) { return *this; }





  this->SetSize( rhs.GetSize() );


  this->VnlVectorType::operator=(rhs);

  return *this;
}


template < typename TValueType >
const typename Array<TValueType>
::Self&
Array<TValueType>
::operator=( const VnlVectorType& rhs )
{

  if( this == &rhs ) { return *this; }





  this->SetSize( rhs.size() );


  this->VnlVectorType::operator=(rhs);

  return *this;
}


}
# 134 "/tmp/installed/include/InsightToolkit/Common/itkArray.h" 2
# 26 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.h"
#define __itkArray2D_h 




namespace itk
{
# 43 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.h"
template <typename TValueType >
class Array2D : public vnl_matrix< TValueType >
{
public:


  typedef TValueType ValueType;
  typedef Array2D Self;
  typedef vnl_matrix<TValueType> VnlMatrixType;

public:

  Array2D();
  Array2D(unsigned int rows,unsigned int cols);
  Array2D( const Self & array );
  Array2D( const VnlMatrixType & matrix );

  const Self & operator=( const Self & array );
  const Self & operator=( const VnlMatrixType & matrix );

  void Fill (TValueType const& v) { fill(v); }


  void SetSize(unsigned int m, unsigned int n);



  ~Array2D() {};

};



template <typename TValueType >
std::ostream & operator<<(std::ostream &os, const Array2D<TValueType> &arr)
{
  const unsigned int numberOfColumns = arr.cols();
  const unsigned int numberOfRows = arr.rows();
  const signed int lastColumn = (signed int) numberOfColumns - 1;

  if (false) { } else for (unsigned int r=0; r < numberOfRows; ++r)
    {
    os << "[";
    if (false) { } else for ( signed int c=0; c < lastColumn; ++c)
      {
      os << arr(r,c) << ", ";
      }
    if (numberOfColumns >= 1)
      {
      os << arr(r,lastColumn);
      }
    os << "]" << std::endl;
    }

  return os;
}

}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.txx"
#define _itkArray2D_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.txx" 2

namespace itk
{





template < typename TValueType >
Array2D<TValueType >
::Array2D():vnl_matrix<TValueType>()
{
}





template < typename TValueType >
Array2D<TValueType >
::Array2D(unsigned int rows,unsigned int cols):vnl_matrix<TValueType>(rows,cols)
{
}






template < typename TValueType >
Array2D<TValueType >
::Array2D( const VnlMatrixType & matrix ):
  vnl_matrix<TValueType>( matrix )
{
}






template < typename TValueType >
Array2D<TValueType >
::Array2D( const Self & array )
  :vnl_matrix<TValueType>( array )
{
}






template < typename TValueType >
const Array2D<TValueType > &
Array2D<TValueType >
::operator=( const Self & array )
{
  this->VnlMatrixType::operator=( array );
  return *this;
}






template < typename TValueType >
const Array2D<TValueType > &
Array2D<TValueType >
::operator=( const VnlMatrixType & matrix )
{
  this->VnlMatrixType::operator=( matrix );
  return *this;
}

template < typename TValueType >
void Array2D<TValueType >
::SetSize(unsigned int m, unsigned int n)
{
  this->set_size(m, n);
}





}
# 105 "/tmp/installed/include/InsightToolkit/Common/itkArray2D.h" 2
# 27 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h" 2




namespace itk
{
# 63 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h"
template <class TScalarType,
          unsigned int NInputDimensions=3,
          unsigned int NOutputDimensions=3>
class Transform : public Object
{
public:

  typedef Transform Self;
  typedef Object Superclass;
  typedef SmartPointer< Self > Pointer;
  typedef SmartPointer< const Self > ConstPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "Transform";};


  static const unsigned int InputSpaceDimension = NInputDimensions;
  static const unsigned int OutputSpaceDimension = NOutputDimensions;


  typedef TScalarType ScalarType;


  typedef Array< double > ParametersType;


  typedef Array2D< double > JacobianType;


  typedef Vector<TScalarType, NInputDimensions> InputVectorType;
  typedef Vector<TScalarType, NOutputDimensions> OutputVectorType;


  typedef CovariantVector<TScalarType, NInputDimensions> InputCovariantVectorType;
  typedef CovariantVector<TScalarType, NOutputDimensions> OutputCovariantVectorType;


  typedef vnl_vector_fixed<TScalarType, NInputDimensions> InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType, NOutputDimensions> OutputVnlVectorType;


  typedef Point<TScalarType, NInputDimensions> InputPointType;
  typedef Point<TScalarType, NOutputDimensions> OutputPointType;


  virtual OutputPointType TransformPoint(const InputPointType & ) const
    { return OutputPointType(); }


  virtual OutputVectorType TransformVector(const InputVectorType &) const
    { return OutputVectorType(); }


  virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const
    { return OutputVnlVectorType(); }


  virtual OutputCovariantVectorType TransformCovariantVector(
    const InputCovariantVectorType &) const
    { return OutputCovariantVectorType(); }


  virtual void SetParameters( const ParametersType & )
    { { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "Subclasses should override this method"; ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/Common/itkTransform.h", 129, message.str().c_str()); throw e_; } };


  virtual const ParametersType& GetParameters(void) const
    { { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "Subclasses should override this method"; ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/Common/itkTransform.h", 133, message.str().c_str()); throw e_; };
      return m_Parameters; };
# 163 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h"
  virtual const JacobianType & GetJacobian(const InputPointType &) const
    { { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "Subclass should override this method"; ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/Common/itkTransform.h", 164, message.str().c_str()); throw e_; };
      return m_Jacobian; };



  virtual unsigned int GetNumberOfParameters(void) const
                      { return m_Parameters.Size(); }



  bool GetInverse(Self*) const {return false;}


protected:
  Transform();
  Transform(unsigned int Dimension, unsigned int NumberOfParameters);
  virtual ~Transform() {};


  mutable ParametersType m_Parameters;
  mutable JacobianType m_Jacobian;

private:
  Transform(const Self&);
  void operator=(const Self&);


};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkTransform.txx" 1
# 19 "/tmp/installed/include/InsightToolkit/Common/itkTransform.txx"
#define _itkTransform_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h" 1
# 22 "/tmp/installed/include/InsightToolkit/Common/itkTransform.txx" 2

namespace itk
{





template < class TScalarType,
           unsigned int NInputDimensions,
           unsigned int NOutputDimensions >
Transform< TScalarType,NInputDimensions,NOutputDimensions>
::Transform():
  m_Parameters(1),
  m_Jacobian(NOutputDimensions,1)
{
}






template < class TScalarType,
           unsigned int NInputDimensions,
           unsigned int NOutputDimensions >
Transform< TScalarType,NInputDimensions,NOutputDimensions>
::Transform(unsigned int dimension,unsigned int numberOfParameters):
  m_Parameters(numberOfParameters),
  m_Jacobian(dimension,numberOfParameters)
{
}



}
# 197 "/tmp/installed/include/InsightToolkit/Common/itkTransform.h" 2
# 25 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 1
# 26 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h" 2


namespace itk
{
# 108 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
template <
 class TScalarType=double,
 unsigned int NDimensions=3>
class AffineTransform : public Transform< TScalarType,
                                          NDimensions,
                                          NDimensions >
{
public:

  typedef AffineTransform Self;
  typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  virtual const char *GetNameOfClass() const {return "AffineTransform";};


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  static const unsigned int SpaceDimension = NDimensions;
  static const unsigned int ParametersDimension = NDimensions*(NDimensions+1);




  typedef typename Superclass::ParametersType ParametersType;


  typedef typename Superclass::JacobianType JacobianType;


  typedef typename Superclass::ScalarType ScalarType;


  typedef Vector<TScalarType,
                 (Self::SpaceDimension)> InputVectorType;
  typedef Vector<TScalarType,
                 (Self::SpaceDimension)> OutputVectorType;


  typedef CovariantVector<TScalarType,
                          (Self::SpaceDimension)> InputCovariantVectorType;
  typedef CovariantVector<TScalarType,
                          (Self::SpaceDimension)> OutputCovariantVectorType;


  typedef vnl_vector_fixed<TScalarType,
                           (Self::SpaceDimension)> InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType,
                           (Self::SpaceDimension)> OutputVnlVectorType;


  typedef Point<TScalarType,
                (Self::SpaceDimension)> InputPointType;
  typedef Point<TScalarType,
                (Self::SpaceDimension)> OutputPointType;


  typedef Matrix<TScalarType, (Self::SpaceDimension),
                 (Self::SpaceDimension)> MatrixType;


  typedef OutputVectorType OffsetType;




  const OffsetType & GetOffset(void) const
      { return m_Offset; }





  const MatrixType & GetMatrix() const
      { return m_Matrix; }




  void SetIdentity( void )
    { m_Matrix.SetIdentity();
      m_Offset.Fill( 0.0 );
      m_MatrixMTime.Modified();
      this->Modified();
    }
# 204 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  bool GetInverse(Self* inverse) const;






  void SetOffset(const OffsetType &offset)
      { m_Offset = offset; this->Modified(); return; }





  void SetMatrix(const MatrixType &matrix)
      { m_Matrix = matrix; m_MatrixMTime.Modified(); this->Modified(); return; }




  void SetParameters( const ParametersType & parameters );


  const ParametersType& GetParameters(void) const;
# 239 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  void Compose(const Self * other, bool pre=0);






  void Translate(const OutputVectorType &offset, bool pre=0);
# 258 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  void Scale(const OutputVectorType &factor, bool pre=0);
  void Scale(const TScalarType &factor, bool pre=0);
# 275 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  void Rotate(int axis1, int axis2, TScalarType angle, bool pre=0);
# 289 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  void Rotate2D(TScalarType angle, bool pre=0);
# 303 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  void Rotate3D(const OutputVectorType &axis, TScalarType angle, bool pre=0);
# 314 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  void Shear(int axis1, int axis2, TScalarType coef, bool pre=0);
# 323 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  OutputPointType TransformPoint (const InputPointType &point ) const;
  OutputVectorType TransformVector(const InputVectorType &vector) const;
  OutputVnlVectorType TransformVector(const InputVnlVectorType &vector) const;
  OutputCovariantVectorType TransformCovariantVector(
                             const InputCovariantVectorType &vector) const;






  inline InputPointType BackTransform(const OutputPointType &point ) const;
  inline InputVectorType BackTransform(const OutputVectorType &vector) const;
  inline InputVnlVectorType BackTransform(const OutputVnlVectorType &vector) const;

  inline InputCovariantVectorType BackTransform(
                              const OutputCovariantVectorType &vector) const;







  InputPointType BackTransformPoint(const OutputPointType &point) const;
# 360 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h"
  ScalarType Metric(const Self * other) const;




  ScalarType Metric(void) const;







  const JacobianType & GetJacobian(const InputPointType &point ) const;



  MatrixType GetInverseMatrix() const;







   typename AffineTransform::Pointer Inverse(void) const;


protected:







  AffineTransform(const MatrixType &matrix, const OutputVectorType &offset);
  AffineTransform(unsigned int outputSpaceDimension, unsigned int parametersDimension);
  AffineTransform();


  virtual ~AffineTransform();


  void PrintSelf(std::ostream &s, Indent indent) const;


  mutable TimeStamp m_InverseMatrixMTime;
  TimeStamp m_MatrixMTime;

private:

  AffineTransform(const Self & other);
  const Self & operator=( const Self & );


  MatrixType m_Matrix;
  OffsetType m_Offset;
  mutable MatrixType m_InverseMatrix;
  mutable bool m_Singular;


};

}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.txx"
#define _itkAffineTransform_txx 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h" 1
# 22 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.txx" 2



namespace itk
{


template<class TScalarType, unsigned int NDimensions>
AffineTransform<TScalarType, NDimensions>::
AffineTransform():Superclass(SpaceDimension,ParametersDimension)
{
  m_Matrix.SetIdentity();
  m_Offset.Fill( 0 );
  m_Singular = false;
  m_InverseMatrix.SetIdentity();
}



template<class TScalarType, unsigned int NDimensions>
AffineTransform<TScalarType, NDimensions>::
AffineTransform( unsigned int outputSpaceDimension,
                 unsigned int parametersDimension ):
  Superclass(outputSpaceDimension,parametersDimension)
{
  m_Matrix.SetIdentity();
  m_Offset.Fill( 0 );
  m_Singular = false;
}




template<class TScalarType, unsigned int NDimensions>
AffineTransform<TScalarType, NDimensions>::
AffineTransform(const MatrixType &matrix, const OutputVectorType &offset)
{
  m_Matrix = matrix;
  m_Offset = offset;
  m_MatrixMTime.Modified();
  this->Modified();
}





template<class TScalarType, unsigned int NDimensions>
AffineTransform<TScalarType, NDimensions>::
~AffineTransform()
{
  return;
}




template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
PrintSelf(std::ostream &os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  unsigned int i, j;

  os << indent << "Matrix: " << std::endl;
  if (false) { } else for (i = 0; i < NDimensions; i++)
    {
    os << indent.GetNextIndent();
    if (false) { } else for (j = 0; j < NDimensions; j++)
      {
      os << m_Matrix[i][j] << " ";
      }
    os << std::endl;
    }

  os << indent << "Offset: " << m_Offset << std::endl;

  os << indent << "Inverse: " << std::endl;
  if (false) { } else for (i = 0; i < NDimensions; i++)
    {
    os << indent.GetNextIndent();
    if (false) { } else for (j = 0; j < NDimensions; j++)
      {
      os << this->GetInverseMatrix()[i][j] << " ";
      }
    os << std::endl;
    }
  os << indent << "Singular: " << m_Singular << std::endl;

}



template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Compose(const Self * other, bool pre)
{
  if (pre)
    {
    m_Offset = m_Matrix * other->m_Offset + m_Offset;
    m_Matrix = m_Matrix * other->m_Matrix;
    }
  else
    {
    m_Offset = other->m_Matrix * m_Offset + other->m_Offset;
    m_Matrix = other->m_Matrix * m_Matrix;
    }
  m_MatrixMTime.Modified();
  this->Modified();
  return;
}



template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Translate(const OutputVectorType &offset, bool pre)
{
  if (pre)
    {
    m_Offset += m_Matrix * offset;
    }
  else
    {
    m_Offset += offset;
    }
  this->Modified();
  return;
}



template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Scale(const TScalarType &factor, bool pre)
{
  if (pre)
    {
    m_Matrix *= factor;
    }
  else
    {
    m_Matrix *= factor;
    m_Offset *= factor;
    }
  m_MatrixMTime.Modified();
  this->Modified();
  return;
}




template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Scale(const OutputVectorType &factor, bool pre)
{
  MatrixType trans;
  unsigned int i, j;

  if (false) { } else for (i = 0; i < NDimensions; i++)
    {
    if (false) { } else for (j = 0; j < NDimensions; j++)
      {
      trans[i][j] = 0.0;
      }
    trans[i][i] = factor[i];
    }
  if (pre)
    {
    m_Matrix = m_Matrix * trans;
    }
  else
    {
    m_Matrix = trans * m_Matrix;
    m_Offset = trans * m_Offset;
    }
  m_MatrixMTime.Modified();
  this->Modified();
  return;
}




template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Rotate(int axis1, int axis2, TScalarType angle, bool pre)
{
  MatrixType trans;
  unsigned int i, j;

  if (false) { } else for (i = 0; i < NDimensions; i++)
    {
    if (false) { } else for (j = 0; j < NDimensions; j++)
      {
      trans[i][j] = 0.0;
      }
    trans[i][i] = 1.0;
    }
  trans[axis1][axis1] = cos(angle);
  trans[axis1][axis2] = sin(angle);
  trans[axis2][axis1] = -sin(angle);
  trans[axis2][axis2] = cos(angle);
  if (pre)
    {
    m_Matrix = m_Matrix * trans;
    }
  else
    {
    m_Matrix = trans * m_Matrix;
    m_Offset = trans * m_Offset;
    }
  m_MatrixMTime.Modified();
  this->Modified();
  return;
}





template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Rotate2D(TScalarType angle, bool pre)
{
  MatrixType trans;

  trans[0][0] = cos(angle);
  trans[0][1] = sin(angle);
  trans[1][0] = -sin(angle);
  trans[1][1] = cos(angle);
  if (pre)
    {
    m_Matrix = m_Matrix * trans;
    }
  else
    {
    m_Matrix = trans * m_Matrix;
    m_Offset = trans * m_Offset;
    }
  m_MatrixMTime.Modified();
  this->Modified();
  return;
}






template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Rotate3D(const OutputVectorType &axis, TScalarType angle, bool pre)
{
  MatrixType trans;
  ScalarType r, x1, x2, x3;
  ScalarType q0, q1, q2, q3;


  r = sqrt(axis[0]*axis[0] + axis[1]*axis[1] + axis[2]*axis[2]);
  x1 = axis[0] / r;
  x2 = axis[1] / r;
  x3 = axis[2] / r;


  q0 = cos(angle/2.0);
  q1 = x1 * sin(angle/2.0);
  q2 = x2 * sin(angle/2.0);
  q3 = x3 * sin(angle/2.0);


  trans[0][0] = q0*q0 + q1*q1 - q2*q2 - q3*q3;
  trans[0][1] = 2.0*(q1*q2 - q0*q3);
  trans[0][2] = 2.0*(q1*q3 + q0*q2);
  trans[1][0] = 2.0*(q1*q2 + q0*q3);
  trans[1][1] = q0*q0 + q2*q2 - q1*q1 - q3*q3;
  trans[1][2] = 2.0*(q2*q3 - q0*q1);
  trans[2][0] = 2.0*(q1*q3 - q0*q2);
  trans[2][1] = 2.0*(q2*q3 + q0*q1);
  trans[2][2] = q0*q0 + q3*q3 - q1*q1 - q2*q2;


  if (pre)
    {
    m_Matrix = m_Matrix * trans;
    }
  else
    {
    m_Matrix = trans * m_Matrix;
    m_Offset = trans * m_Offset;
    }
  m_MatrixMTime.Modified();
  this->Modified();
  return;
}



template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
Shear(int axis1, int axis2, TScalarType coef, bool pre)
{
  MatrixType trans;
  unsigned int i, j;

  if (false) { } else for (i = 0; i < NDimensions; i++)
    {
    if (false) { } else for (j = 0; j < NDimensions; j++)
      {
      trans[i][j] = 0.0;
      }
    trans[i][i] = 1.0;
    }
  trans[axis1][axis2] = coef;
  if (pre)
    {
    m_Matrix = m_Matrix * trans;
    }
  else
    {
    m_Matrix = trans * m_Matrix;
    m_Offset = trans * m_Offset;
    }
  m_MatrixMTime.Modified();
  this->Modified();
  return;
}



template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::OutputPointType
AffineTransform<TScalarType, NDimensions>::
TransformPoint(const InputPointType &point) const
{
  return m_Matrix * point + m_Offset;
}



template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::OutputVectorType
AffineTransform<TScalarType, NDimensions>::
TransformVector(const InputVectorType &vect) const
{
  return m_Matrix * vect;
}



template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::OutputVnlVectorType
AffineTransform<TScalarType, NDimensions>::
TransformVector(const InputVnlVectorType &vect) const {
  return m_Matrix * vect;
}



template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::OutputCovariantVectorType
AffineTransform<TScalarType, NDimensions>::
TransformCovariantVector(const InputCovariantVectorType &vec) const
{
  OutputCovariantVectorType result;

  if (false) { } else for (unsigned int i = 0; i < NDimensions; i++)
    {
    result[i] = NumericTraits<ScalarType>::Zero;
    if (false) { } else for (unsigned int j = 0; j < NDimensions; j++)
      {
      result[i] += this->GetInverseMatrix()[j][i]*vec[j];
      }
    }
  return result;
}



template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::InputPointType
AffineTransform<TScalarType, NDimensions>::
BackTransform(const OutputPointType &point) const
{
  InputPointType result;
  ScalarType temp[NDimensions];
  unsigned int i, j;

  if (false) { } else for (j = 0; j < NDimensions; j++)
    {
    temp[j] = point[j] - m_Offset[j];
    }

  if (false) { } else for (i = 0; i < NDimensions; i++)
    {
    result[i] = 0.0;
    if (false) { } else for (j = 0; j < NDimensions; j++)
      {
      result[i] += this->GetInverseMatrix()[i][j]*temp[j];
      }
    }
  return result;
}





template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::InputVectorType
AffineTransform<TScalarType, NDimensions>::
BackTransform(const OutputVectorType &vect ) const
{
  return this->GetInverseMatrix() * vect;
}





template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::InputVnlVectorType
AffineTransform<TScalarType, NDimensions>::
BackTransform(const OutputVnlVectorType &vect ) const
{
  return this->GetInverseMatrix() * vect;
}




template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::InputCovariantVectorType
AffineTransform<TScalarType, NDimensions>::
BackTransform(const OutputCovariantVectorType &vec) const
{

  InputCovariantVectorType result;

  if (false) { } else for (unsigned int i = 0; i < NDimensions; i++)
    {
    result[i] = NumericTraits<ScalarType>::Zero;
    if (false) { } else for (unsigned int j = 0; j < NDimensions; j++)
      {
      result[i] += m_Matrix[j][i]*vec[j];
      }
    }
  return result;
}





template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::InputPointType
AffineTransform<TScalarType, NDimensions>::
BackTransformPoint(const OutputPointType &point) const
{
  InputPointType result;
  ScalarType temp[NDimensions];
  unsigned int i, j;

  if (false) { } else for (j = 0; j < NDimensions; j++)
    {
    temp[j] = point[j] - m_Offset[j];
    }

  if (false) { } else for (i = 0; i < NDimensions; i++)
    {
    result[i] = 0.0;
    if (false) { } else for (j = 0; j < NDimensions; j++)
      {
      result[i] += this->GetInverseMatrix()[i][j]*temp[j];
      }
    }
  return result;
}



template<class TScalarType, unsigned int NDimensions>
bool
AffineTransform<TScalarType, NDimensions>::
GetInverse( Self* inverse) const
{
  if(!inverse)
    {
    return false;
    }

  this->GetInverseMatrix();
  if(m_Singular)
    {
    return false;
    }

  inverse->m_Matrix = this->GetInverseMatrix();
  inverse->m_InverseMatrix = m_Matrix;
  inverse->m_Offset = -(this->GetInverseMatrix() * m_Offset);
  return true;
}


template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::ScalarType
AffineTransform<TScalarType, NDimensions>::
Metric(const Self * other) const
{
  ScalarType result = 0.0, term;

  if (false) { } else for (unsigned int i = 0; i < NDimensions; i++)
    {
    if (false) { } else for (unsigned int j = 0; j < NDimensions; j++)
      {
      term = m_Matrix[i][j] - other->m_Matrix[i][j];
      result += term * term;
      }
    term = m_Offset[i] - other->m_Offset[i];
    result += term * term;
    }
  return sqrt(result);
}




template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::ScalarType
AffineTransform<TScalarType, NDimensions>::
Metric(void) const
{
  ScalarType result = 0.0, term;

  if (false) { } else for (unsigned int i = 0; i < NDimensions; i++)
    {
    if (false) { } else for (unsigned int j = 0; j < NDimensions; j++)
      {
      if (i == j)
        {
        term = m_Matrix[i][j] - 1.0;
        }
      else
        {
        term = m_Matrix[i][j];
        }
      result += term * term;
      }
    term = m_Offset[i];
    result += term * term;
    }

  return sqrt(result);
}






template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::MatrixType
AffineTransform<TScalarType, NDimensions>::
GetInverseMatrix( void ) const
{

  if(m_InverseMatrixMTime != m_MatrixMTime)
    {
    m_Singular = false;
    try
      {
      m_InverseMatrix = m_Matrix.GetInverse();
      }
    catch(...)
      {
      m_Singular = true;
      }
     m_InverseMatrixMTime = m_MatrixMTime;
    }

  return m_InverseMatrix;
}






template<class TScalarType, unsigned int NDimensions>
const typename AffineTransform<TScalarType, NDimensions>::ParametersType &
AffineTransform<TScalarType, NDimensions>::
GetParameters( void ) const
{


  unsigned int par = 0;

  if (false) { } else for(unsigned int row=0; row<NDimensions; row++)
    {
    if (false) { } else for(unsigned int col=0; col<NDimensions; col++)
      {
      this->m_Parameters[par] = this->m_Matrix[row][col];
      ++par;
      }
    }


  if (false) { } else for(unsigned int i=0; i<NDimensions; i++)
    {
    this->m_Parameters[par] = this->m_Offset[i];
    ++par;
    }

  return this->m_Parameters;

}





template<class TScalarType, unsigned int NDimensions>
void
AffineTransform<TScalarType, NDimensions>::
SetParameters( const ParametersType & parameters )
{


  unsigned int par = 0;

  this->m_Parameters = parameters;

  if (false) { } else for(unsigned int row=0; row<NDimensions; row++)
    {
    if (false) { } else for(unsigned int col=0; col<NDimensions; col++)
      {
      this->m_Matrix[row][col] = this->m_Parameters[par];
      ++par;
      }
    }


  if (false) { } else for(unsigned int i=0; i<NDimensions; i++)
    {
    this->m_Offset[i] = this->m_Parameters[par];
    ++par;
    }


  this->m_MatrixMTime.Modified();
  this->Modified();
}



template<class TScalarType, unsigned int NDimensions>
const typename AffineTransform<TScalarType, NDimensions>::JacobianType &
AffineTransform<TScalarType, NDimensions>::
GetJacobian( const InputPointType & p ) const
{





  this->m_Jacobian.Fill( 0.0 );

  unsigned int blockOffset = 0;

  if (false) { } else for(unsigned int block=0; block < SpaceDimension; block++)
    {
    if (false) { } else for(unsigned int dim=0; dim < SpaceDimension; dim++ )
      {
      this->m_Jacobian( block , blockOffset + dim ) = p[dim];
      }

    blockOffset += SpaceDimension;

    }

  if (false) { } else for(unsigned int dim=0; dim < SpaceDimension; dim++ )
    {


    this->m_Jacobian( dim , blockOffset + dim ) = 1.0;
    }

  return this->m_Jacobian;

}


template<class TScalarType, unsigned int NDimensions>
typename AffineTransform<TScalarType, NDimensions>::Pointer
AffineTransform<TScalarType, NDimensions>::
Inverse( void ) const
{
  { if (itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "WARNING: In " "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.txx" ", line " << 730 << "\n" << this->GetNameOfClass() << " (" << this << "): " "Inverse() is deprecated.  Please use GetInverse() instead." << "\n\n"; itk::OutputWindowDisplayWarningText(itkmsg.str().c_str());} };
  Pointer result = New();
  result->m_Matrix = this->GetInverseMatrix();
  result->m_InverseMatrix = m_Matrix;
  result->m_Offset = -(this->GetInverseMatrix() * m_Offset);
  result->m_Singular = false;
  return result;
}



}
# 429 "/tmp/installed/include/InsightToolkit/Common/itkAffineTransform.h" 2
# 25 "/tmp/installed/include/InsightToolkit/Common/itkImage.txx" 2

namespace itk
{




template<class TPixel, unsigned int VImageDimension>
Image<TPixel, VImageDimension>
::Image()
{
  m_Buffer = PixelContainer::New();
}



template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::Allocate()
{
  unsigned long num;

  this->ComputeOffsetTable();
  num = this->GetOffsetTable()[VImageDimension];

  m_Buffer->Reserve(num);
}

template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::Initialize()
{






  Superclass::Initialize();




  m_Buffer = PixelContainer::New();
}


template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::FillBuffer (const TPixel& value)
{
  const unsigned long numberOfPixels =
    this->GetBufferedRegion().GetNumberOfPixels();

  if (false) { } else for(unsigned int i=0; i<numberOfPixels; i++)
    {
    (*m_Buffer)[i] = value;
    }
}

template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::SetPixelContainer(PixelContainer *container)
{
  if (m_Buffer != container)
    {
    m_Buffer = container;
    this->Modified();
    }
}


template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::Graft(const ImageBase<VImageDimension> *data)
{

  Superclass::Graft( data );

  if ( data )
    {

    const Image<TPixel, VImageDimension> *imgData;

    imgData = dynamic_cast<const Image<TPixel, VImageDimension>*>(data);

    if (imgData)
      {

      this->SetPixelContainer(
        const_cast<typename Image<TPixel, VImageDimension>::PixelContainer *>
        (imgData->GetPixelContainer()) );
      }
    else
      {

      { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "itk::Image::Graft() cannot cast " << typeid(data).name() << " to " << typeid(const Self *).name(); ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/Common/itkImage.txx", 128, message.str().c_str()); throw e_; };


      }
    }
}



template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::SetSpacing(const double spacing[VImageDimension] )
{
  SpacingType s(spacing);
  this->SetSpacing(s);
}



template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::SetSpacing(const float spacing[VImageDimension] )
{
  Vector<float, VImageDimension> sf(spacing);
  SpacingType s;
  s.CastFrom( sf );
  this->SetSpacing(s);
}


template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::SetOrigin(const double origin[VImageDimension] )
{
  PointType p(origin);
  this->SetOrigin( p );
}



template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::SetOrigin(const float origin[VImageDimension] )
{
  Point<float, VImageDimension> of(origin);
  PointType p;
  p.CastFrom( of );
  this->SetOrigin( p );
}





template<class TPixel, unsigned int VImageDimension>
void
Image<TPixel, VImageDimension>
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  os << indent << "PixelContainer: " << std::endl;
  m_Buffer->Print(os, indent.GetNextIndent());


}


}
# 387 "/tmp/installed/include/InsightToolkit/Common/itkImage.h" 2
# 24 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
#define __itkImageSource_h 




namespace itk
{
# 51 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
template <class TOutputImage>
class ImageSource : public ProcessObject
{
public:

  typedef ImageSource Self;
  typedef ProcessObject Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  typedef DataObject::Pointer DataObjectPointer;


  virtual const char *GetNameOfClass() const {return "ImageSource";};


  typedef TOutputImage OutputImageType;
  typedef typename OutputImageType::Pointer OutputImagePointer;
  typedef typename OutputImageType::RegionType OutputImageRegionType;
  typedef typename OutputImageType::PixelType OutputImagePixelType;
# 113 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
  OutputImageType * GetOutput(void);
  OutputImageType * GetOutput(unsigned int idx);
# 151 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
  virtual void GraftOutput(OutputImageType *output);







  virtual void GraftNthOutput(unsigned int idx, OutputImageType *output);
# 174 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
  virtual DataObjectPointer MakeOutput(unsigned int idx);

protected:
  ImageSource();
  virtual ~ImageSource() {}
# 195 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
  virtual void GenerateData();
# 219 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
  virtual
  void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                            int threadId );







  virtual void AllocateOutputs();
# 241 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
  virtual void BeforeThreadedGenerateData() {};
# 253 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
  virtual void AfterThreadedGenerateData() {};






  virtual
  int SplitRequestedRegion(int i, int num, OutputImageRegionType& splitRegion);




  static void * ThreaderCallback( void *arg );


  struct ThreadStruct
  {
   Pointer Filter;
  };

private:
  ImageSource(const Self&);
  void operator=(const Self&);

};
# 298 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h"
}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.txx" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.txx"
#define _itkImageSource_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h" 1
# 23 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.txx" 2



namespace itk
{




template<class TOutputImage>
ImageSource<TOutputImage>
::ImageSource()
{


  typename TOutputImage::Pointer output
    = static_cast<TOutputImage*>(this->MakeOutput(0).GetPointer());
  this->ProcessObject::SetNumberOfRequiredOutputs(1);
  this->ProcessObject::SetNthOutput(0, output.GetPointer());




  this->ReleaseDataBeforeUpdateFlagOff();
}




template<class TOutputImage>
typename ImageSource<TOutputImage>::DataObjectPointer
ImageSource<TOutputImage>
::MakeOutput(unsigned int)
{
  return static_cast<DataObject*>(TOutputImage::New().GetPointer());
}




template<class TOutputImage>
typename ImageSource<TOutputImage>::OutputImageType *
ImageSource<TOutputImage>
::GetOutput()
{
  if (this->GetNumberOfOutputs() < 1)
    {
    return 0;
    }

  return static_cast<TOutputImage*>
    (this->ProcessObject::GetOutput(0));
}





template<class TOutputImage>
typename ImageSource<TOutputImage>::OutputImageType *
ImageSource<TOutputImage>
::GetOutput(unsigned int idx)
{
  return static_cast<TOutputImage*>
    (this->ProcessObject::GetOutput(idx));
}







template<class TOutputImage>
void
ImageSource<TOutputImage>
::GraftOutput(TOutputImage *graft)
{
  this->GraftNthOutput(0, graft);
}





template<class TOutputImage>
void
ImageSource<TOutputImage>
::GraftNthOutput(unsigned int idx, TOutputImage *graft)
{
  if (idx < this->GetNumberOfOutputs())
    {
    typename ImageSource<TOutputImage>::OutputImageType * output = this->GetOutput(idx);

    if (output && graft)
      {


      output->Graft( graft );
      }
    }
}


template <class TOutputImage>
int
ImageSource<TOutputImage>
::SplitRequestedRegion(int i, int num, OutputImageRegionType& splitRegion)
{

  OutputImageType * outputPtr = this->GetOutput();
  const typename TOutputImage::SizeType& requestedRegionSize
    = outputPtr->GetRequestedRegion().GetSize();

  int splitAxis;
  typename TOutputImage::IndexType splitIndex;
  typename TOutputImage::SizeType splitSize;


  splitRegion = outputPtr->GetRequestedRegion();
  splitIndex = splitRegion.GetIndex();
  splitSize = splitRegion.GetSize();


  splitAxis = outputPtr->GetImageDimension() - 1;
  while (requestedRegionSize[splitAxis] == 1)
    {
    --splitAxis;
    if (splitAxis < 0)
      {
      { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImageSource.txx" ", line " << 153 << "\n" << this->GetNameOfClass() << " (" << this << "): " "  Cannot Split" << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} };
      return 1;
      }
    }


  typename TOutputImage::SizeType::SizeValueType range = requestedRegionSize[splitAxis];
  int valuesPerThread = (int)::ceil(range/(double)num);
  int maxThreadIdUsed = (int)::ceil(range/(double)valuesPerThread) - 1;


  if (i < maxThreadIdUsed)
    {
    splitIndex[splitAxis] += i*valuesPerThread;
    splitSize[splitAxis] = valuesPerThread;
    }
  if (i == maxThreadIdUsed)
    {
    splitIndex[splitAxis] += i*valuesPerThread;

    splitSize[splitAxis] = splitSize[splitAxis] - i*valuesPerThread;
    }


  splitRegion.SetIndex( splitIndex );
  splitRegion.SetSize( splitSize );

  { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/Common/itkImageSource.txx" ", line " << 180 << "\n" << this->GetNameOfClass() << " (" << this << "): " "  Split Piece: " << splitRegion << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} };

  return maxThreadIdUsed + 1;
}


template <class TOutputImage>
void
ImageSource<TOutputImage>
::AllocateOutputs()
{
  OutputImagePointer outputPtr;


  if (false) { } else for (unsigned int i=0; i < this->GetNumberOfOutputs(); i++)
    {
    outputPtr = this->GetOutput(i);
    outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion());
    outputPtr->Allocate();
    }
}


template <class TOutputImage>
void
ImageSource<TOutputImage>
::GenerateData()
{


  this->AllocateOutputs();




  this->BeforeThreadedGenerateData();


  ThreadStruct str;
  str.Filter = this;

  this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads());
  this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str);


  this->GetMultiThreader()->SingleMethodExecute();



  this->AfterThreadedGenerateData();

}




template <class TOutputImage>
void
ImageSource<TOutputImage>
::ThreadedGenerateData(const OutputImageRegionType&,
                       int)
{
  { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " "subclass should override this method!!!"; ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/Common/itkImageSource.txx", 242, message.str().c_str()); throw e_; };
}




template <class TOutputImage>
void *
ImageSource<TOutputImage>
::ThreaderCallback( void *arg )
{
  ThreadStruct *str;
  int total, threadId, threadCount;

  threadId = ((MultiThreader::ThreadInfoStruct *)(arg))->ThreadID;
  threadCount = ((MultiThreader::ThreadInfoStruct *)(arg))->NumberOfThreads;

  str = (ThreadStruct *)(((MultiThreader::ThreadInfoStruct *)(arg))->UserData);



  typename TOutputImage::RegionType splitRegion;
  total = str->Filter->SplitRequestedRegion(threadId, threadCount,
                                            splitRegion);

  if (threadId < total)
    {
    str->Filter->ThreadedGenerateData(splitRegion, threadId);
    }







  return __null;
}


}
# 302 "/tmp/installed/include/InsightToolkit/Common/itkImageSource.h" 2
# 25 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkConceptChecking.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkConceptChecking.h"
#define _itkConceptChecking_h 
# 34 "/tmp/installed/include/InsightToolkit/Common/itkConceptChecking.h"
#define ITK_CONCEPT_IMPLEMENTATION_STANDARD 
# 47 "/tmp/installed/include/InsightToolkit/Common/itkConceptChecking.h"
#define itkConceptConstraintsMacro() template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation


#define itkConceptMacro(name,concept) enum { name = sizeof concept }
# 77 "/tmp/installed/include/InsightToolkit/Common/itkConceptChecking.h"
namespace itk
{



namespace Concept
{
# 92 "/tmp/installed/include/InsightToolkit/Common/itkConceptChecking.h"
namespace Detail
{

template <typename T> struct UniqueType {};
template <int> struct UniqueType_int {};
template <unsigned int> struct UniqueType_unsigned_int {};
template <bool> struct UniqueType_bool {};







template <typename T> inline void IgnoreUnusedVariable(T) {}






template <class T>
void RequireBooleanExpression(const T& t)
{
  bool x = t;
  IgnoreUnusedVariable(x);
}

}



template <typename T>
struct DefaultConstructible
{
  struct Constraints
  {
    void constraints()
      {
      T a;
      Detail::IgnoreUnusedVariable(a);
      }
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct CopyConstructible
{
  struct Constraints
  {
    void constraints()
      {
      T a(b);
      T* p = &a;
      const_constraints(a);
      Detail::IgnoreUnusedVariable(p);
      }
    void const_constraints(const T& a)
      {
      T c(a);
      const T* p = &a;
      Detail::IgnoreUnusedVariable(c);
      Detail::IgnoreUnusedVariable(p);
      }
    T b;
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T1, typename T2>
struct Convertible
{
  struct Constraints
  {
    void constraints()
      {
      T2 b = a;
      Detail::IgnoreUnusedVariable(b);
      }
    T1 a;
  };
  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct Assignable
{
  struct Constraints
  {
    void constraints()
      {
      a = a;
      const_constraints(a);
      }
    void const_constraints(const T& b)
      {
      a = b;
      }
    T a;
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct LessThanComparable
{
  struct Constraints
  {
    void constraints()
      {
      Detail::RequireBooleanExpression(a < b);
      }
    T a, b;
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct EqualityComparable
{
  struct Constraints
  {
    void constraints()
      {
      Detail::RequireBooleanExpression(a == b);
      Detail::RequireBooleanExpression(a != b);
      }
    T a, b;
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct Comparable
{
  struct Constraints
  {
    void constraints()
      {
      Detail::RequireBooleanExpression(a < b);
      Detail::RequireBooleanExpression(a > b);
      Detail::RequireBooleanExpression(a <= b);
      Detail::RequireBooleanExpression(a >= b);
      Detail::RequireBooleanExpression(a == b);
      Detail::RequireBooleanExpression(a != b);
      }
    T a, b;
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct AdditiveOperators
{
  struct Constraints
  {
    void constraints()
      {
      a = b + b;
      a = b - b;
      a += b;
      a -= b;
      const_constraints(b);
      }
    void const_constraints(const T& c)
      {
      a = c + c;
      a = c - c;
      a += c;
      a -= c;
      }
    T a, b;
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct MultiplicativeOperators
{
  struct Constraints
  {
    void constraints()
      {
      a = b * b;
      a = b / b;
      a *= b;
      a /= b;
      const_constraints(b);
      }
    void const_constraints(const T& c)
      {
      a = c * c;
      a = c / c;
      a *= c;
      a /= c;
      }
    T a, b;
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T>
struct Signed
{
  typedef Signed Self;
  static const bool IsSigned = NumericTraits<T>::is_signed;
  struct Constraints
  {
    typedef Detail::UniqueType_bool<true> TrueT;
    typedef Detail::UniqueType_bool<(Self::IsSigned)> SignedT;
    void constraints()
      {
        SignedT a = TrueT();
        Detail::IgnoreUnusedVariable(a);
      }
  };

  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <typename T1, typename T2>
struct SameType
{
  struct Constraints
  {
    void constraints()
      {
        Detail::UniqueType<T1> a = Detail::UniqueType<T2>();
        Detail::IgnoreUnusedVariable(a);
      }
  };
  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};


template <unsigned int D1, unsigned int D2>
struct SameDimension
{
  struct Constraints
  {
    typedef Detail::UniqueType_unsigned_int<D1> DT1;
    typedef Detail::UniqueType_unsigned_int<D2> DT2;
    void constraints()
      {
        DT1 a = DT2();
        Detail::IgnoreUnusedVariable(a);
      }
  };
  template <void (Constraints::*)()> struct Enforcer {}; typedef Enforcer<&Constraints::constraints> EnforcerInstantiation;
};

}

}
# 26 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
#define __itkImageToImageFilterDetail_h 




namespace itk
{
# 37 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
namespace ImageToImageFilterDetail
{
# 47 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  struct DispatchBase {};
# 56 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <bool>
  struct BooleanDispatch {};
# 67 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <int>
  struct IntDispatch : public DispatchBase {};
# 84 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <unsigned int>
  struct UnsignedIntDispatch : public DispatchBase {};
# 94 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <bool B1, bool B2>
  struct BinaryBooleanDispatch
  {


    typedef BooleanDispatch<B1> FirstType;
    typedef BooleanDispatch<B2> SecondType;
  };







  template <int D1, int D2>
  struct BinaryIntDispatch
  {


    typedef IntDispatch<D1> FirstType;
    typedef IntDispatch<D2> SecondType;
  };
# 129 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <unsigned int D1, unsigned int D2>
  struct BinaryUnsignedIntDispatch : public DispatchBase
  {


    typedef UnsignedIntDispatch<D1> FirstType;
    typedef UnsignedIntDispatch<D2> SecondType;
# 152 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
    typedef IntDispatch<(D1 > D2) - (D1 < D2)> ComparisonType;
    typedef IntDispatch<0> FirstEqualsSecondType;
    typedef IntDispatch<1> FirstGreaterThanSecondType;
    typedef IntDispatch<-1> FirstLessThanSecondType;
  };
# 174 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <unsigned int D1, unsigned int D2>
  void ImageToImageFilterDefaultCopyRegion(const typename
                  BinaryUnsignedIntDispatch<D1, D2>::FirstEqualsSecondType &,
                  ImageRegion<D1> &destRegion,
                  const ImageRegion<D2> &srcRegion)
  {
    destRegion = srcRegion;
  }
# 199 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <unsigned int D1, unsigned int D2>
  void ImageToImageFilterDefaultCopyRegion(const typename
                  BinaryUnsignedIntDispatch<D1, D2>::FirstLessThanSecondType &,
                  ImageRegion<D1> &destRegion,
                  const ImageRegion<D2> &srcRegion)
  {


    unsigned int dim;
    Index<D1> destIndex;
    Size<D1> destSize;
    const Index<D2> &srcIndex = srcRegion.GetIndex();
    const Size<D2> &srcSize = srcRegion.GetSize();


    if (false) { } else for (dim=0; dim < D1; ++dim)
      {
      destIndex[dim] = srcIndex[dim];
      destSize[dim] = srcSize[dim];
      }

    destRegion.SetIndex(destIndex);
    destRegion.SetSize(destSize);
  }
# 240 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <unsigned int D1, unsigned int D2>
  void ImageToImageFilterDefaultCopyRegion(const typename
               BinaryUnsignedIntDispatch<D1, D2>::FirstGreaterThanSecondType &,
               ImageRegion<D1> &destRegion,
               const ImageRegion<D2> &srcRegion)
  {


    unsigned int dim;
    Index<D1> destIndex;
    Size<D1> destSize;
    const Index<D2> &srcIndex = srcRegion.GetIndex();
    const Size<D2> &srcSize = srcRegion.GetSize();


    if (false) { } else for (dim=0; dim < D2; ++dim)
      {
      destIndex[dim] = srcIndex[dim];
      destSize[dim] = srcSize[dim];
      }

    if (false) { } else for (; dim < D1; ++dim)
      {
      destIndex[dim] = 0;
      destSize[dim] = 1;
      }

    destRegion.SetIndex(destIndex);
    destRegion.SetSize(destSize);
  }
# 308 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilterDetail.h"
  template <unsigned int D1, unsigned int D2>
    class ImageRegionCopier
  {
  public:
    virtual void operator() (ImageRegion<D1> &destRegion,
                            const ImageRegion<D2> &srcRegion) const
    {
      ImageToImageFilterDefaultCopyRegion<D1, D2>(
                      typename BinaryUnsignedIntDispatch<D1, D2>::ComparisonType(),
                      destRegion, srcRegion);
    }
  };




  template<unsigned int D1, unsigned int D2>
  std::ostream & operator<<(std::ostream &os, const ImageRegionCopier<D1, D2> &
                            copier)
  {
    os << "ImageRegionCopier: "
       << typeid(ImageRegionCopier<D1, D2>).name() << std::endl;
    return os;
  }


  template<unsigned int D1, unsigned int D2>
  bool operator!=(const ImageRegionCopier<D1, D2> &c1,
                  const ImageRegionCopier<D1, D2> &c2)
  {
    return &c1 != &c2;
  }

}

}
# 27 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h" 2

namespace itk
{
# 63 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h"
template <class TInputImage, class TOutputImage>
class ImageToImageFilter : public ImageSource<TOutputImage>
{
public:

  typedef ImageToImageFilter Self;
  typedef ImageSource<TOutputImage> Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;



  virtual const char *GetNameOfClass() const {return "ImageToImageFilter";};


  typedef typename Superclass::OutputImageRegionType OutputImageRegionType;


  typedef TInputImage InputImageType;
  typedef typename InputImageType::Pointer InputImagePointer;
  typedef typename InputImageType::ConstPointer InputImageConstPointer;
  typedef typename InputImageType::RegionType InputImageRegionType;
  typedef typename InputImageType::PixelType InputImagePixelType;


  static const unsigned int InputImageDimension = TInputImage::ImageDimension;

  static const unsigned int OutputImageDimension = TOutputImage::ImageDimension;



  virtual void SetInput( const InputImageType *image);
  virtual void SetInput( unsigned int, const TInputImage * image);
  const InputImageType * GetInput(void);
  const InputImageType * GetInput(void) const;
  const InputImageType * GetInput(unsigned int idx);
  const InputImageType * GetInput(unsigned int idx) const;


 protected:
  ImageToImageFilter();
  ~ImageToImageFilter();

  virtual void PrintSelf(std::ostream& os, Indent indent) const;
# 132 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h"
  virtual void GenerateInputRequestedRegion();




  typedef ImageToImageFilterDetail::ImageRegionCopier<(Self::OutputImageDimension),
                    (Self::InputImageDimension)> InputToOutputRegionCopierType;



  typedef ImageToImageFilterDetail::ImageRegionCopier<(Self::InputImageDimension),
                    (Self::OutputImageDimension)> OutputToInputRegionCopierType;
# 180 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h"
  virtual void CallCopyOutputRegionToInputRegion(InputImageRegionType &destRegion,
                              const OutputImageRegionType &srcRegion);
# 213 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h"
  virtual void CallCopyInputRegionToOutputRegion(OutputImageRegionType &destRegion,
                              const InputImageRegionType &srcRegion);


private:
  ImageToImageFilter(const Self&);
  void operator=(const Self&);
};
# 264 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h"
}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.txx" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.txx"
#define _itkImageToImageFilter_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h" 1
# 23 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.txx" 2


namespace itk
{




template <class TInputImage, class TOutputImage>
ImageToImageFilter<TInputImage,TOutputImage>
::ImageToImageFilter()
{

  this->SetNumberOfRequiredInputs(1);
}




template <class TInputImage, class TOutputImage>
ImageToImageFilter<TInputImage,TOutputImage>
::~ImageToImageFilter()
{
}





template <class TInputImage, class TOutputImage>
void
ImageToImageFilter<TInputImage,TOutputImage>
::SetInput(const InputImageType *input)
{

  this->ProcessObject::SetNthInput(0,
                                   const_cast< InputImageType * >( input ) );
}





template <class TInputImage, class TOutputImage>
void
ImageToImageFilter<TInputImage,TOutputImage>
::SetInput( unsigned int index, const TInputImage * image )
{

  this->ProcessObject::SetNthInput(index,
                                   const_cast< TInputImage *>( image ) );
}






template <class TInputImage, class TOutputImage>
const typename ImageToImageFilter<TInputImage,TOutputImage>::InputImageType *
ImageToImageFilter<TInputImage,TOutputImage>
::GetInput(void)
{
  if (this->GetNumberOfInputs() < 1)
    {
    return 0;
    }

  return static_cast<const TInputImage * >
    (this->ProcessObject::GetInput(0) );
}






template <class TInputImage, class TOutputImage>
const typename ImageToImageFilter<TInputImage,TOutputImage>::InputImageType *
ImageToImageFilter<TInputImage,TOutputImage>
::GetInput(void) const
{
  if (this->GetNumberOfInputs() < 1)
    {
    return 0;
    }

  return static_cast<const TInputImage * >
    (this->ProcessObject::GetInput(0) );
}




template <class TInputImage, class TOutputImage>
const typename ImageToImageFilter<TInputImage,TOutputImage>::InputImageType *
ImageToImageFilter<TInputImage,TOutputImage>
::GetInput(unsigned int idx)
{
  return static_cast< const TInputImage * >
    (this->ProcessObject::GetInput(idx));
}




template <class TInputImage, class TOutputImage>
const typename ImageToImageFilter<TInputImage,TOutputImage>::InputImageType *
ImageToImageFilter<TInputImage,TOutputImage>
::GetInput(unsigned int idx) const
{
  return static_cast< const TInputImage * >
    (this->ProcessObject::GetInput(idx));
}





template<class TInputImage, class TOutputImage>
void
ImageToImageFilter<TInputImage,TOutputImage>
::GenerateInputRequestedRegion()
{
  Superclass::GenerateInputRequestedRegion();

  if (false) { } else for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx)
    {
    if (this->GetInput(idx))
      {





      typedef ImageBase<InputImageDimension> ImageBaseType;
      typename ImageBaseType::ConstPointer constInput
        = dynamic_cast< ImageBaseType const *>( this->ProcessObject::GetInput(idx) );



      if (constInput.IsNull() )
        {
        continue;
        }



      InputImagePointer input =
        const_cast< TInputImage * > ( this->GetInput(idx) );






      InputImageRegionType inputRegion;
      this->CallCopyOutputRegionToInputRegion(inputRegion, this->GetOutput()->GetRequestedRegion());
      input->SetRequestedRegion( inputRegion );
      }
    }
}

template<class TInputImage, class TOutputImage>
void
ImageToImageFilter<TInputImage,TOutputImage>
::CallCopyOutputRegionToInputRegion(InputImageRegionType &destRegion,
                                    const OutputImageRegionType &srcRegion)
{
  OutputToInputRegionCopierType regionCopier;
  regionCopier(destRegion, srcRegion);
}


template<class TInputImage, class TOutputImage>
void
ImageToImageFilter<TInputImage,TOutputImage>
::CallCopyInputRegionToOutputRegion(OutputImageRegionType &destRegion,
                                    const InputImageRegionType &srcRegion)
{
  InputToOutputRegionCopierType regionCopier;
  regionCopier(destRegion, srcRegion);
}


template<class TInputImage, class TOutputImage>
void
ImageToImageFilter<TInputImage,TOutputImage>
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os, indent);
}



}
# 268 "/tmp/installed/include/InsightToolkit/Common/itkImageToImageFilter.h" 2
# 6 "../src/PerSliceImageFilter.h" 2


template <class TInputImage, class TOutputImage>
class PerSliceImageFilter : public itk::ImageToImageFilter<TInputImage, TOutputImage>
{
public:

  typedef PerSliceImageFilter<TInputImage, TOutputImage> Self;
  typedef itk::ImageToImageFilter<TInputImage, TOutputImage> Superclass;
  typedef itk::SmartPointer<Self> Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;


  virtual const char *GetNameOfClass() const {return "PerSliceImageFilter";};


  typedef typename Superclass::InputImageType InputImageType;
  typedef typename Superclass::InputImagePointer InputImagePointer;
  typedef typename Superclass::InputImageConstPointer InputImageConstPointer;
  typedef typename Superclass::InputImageRegionType InputImageRegionType;
  typedef typename Superclass::InputImagePixelType InputImagePixelType;
  typedef typename Superclass::OutputImageType OutputImageType;

  typedef typename Superclass::OutputImageRegionType OutputImageRegionType;



  static const unsigned int InputImageDimension = TInputImage::ImageDimension;

  static const unsigned int OutputImageDimension = TOutputImage::ImageDimension;



  enum { SameDimension = sizeof (itk::Concept::SameDimension<(Self::InputImageDimension), (Self::OutputImageDimension)>) };




  typedef typename TInputImage::PixelType InputPixelType;
  typedef typename TOutputImage::PixelType OutputPixelType;


  typedef typename InputImageType::SizeValueType SliceNumberType;


  typedef itk::Image<InputPixelType, InputImageDimension-1> InputSliceImageType;
  typedef typename InputSliceImageType::Pointer InputSliceImagePointer;
  typedef itk::Image<OutputPixelType, OutputImageDimension-1> OutputSliceImageType;



  void SetSlicingDirection(unsigned int slicing_direction)
    {
    { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "../src/PerSliceImageFilter.h" ", line " << 59 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting SlicingDirection to " << slicing_direction << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} };
    if (slicing_direction >= InputImageDimension)
      { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "SlicingDirection too high (" << slicing_direction <<", max. is " << InputImageDimension << ")"; ::itk::ExceptionObject e_("../src/PerSliceImageFilter.h", 61, message.str().c_str()); throw e_; };
    if (this->m_SlicingDirection != slicing_direction)
      {
      this->m_SlicingDirection = slicing_direction;
      this->Modified();
      }
    }
  virtual unsigned int GetSlicingDirection () { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "../src/PerSliceImageFilter.h" ", line " << 68 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "SlicingDirection" " of " << this->m_SlicingDirection << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_SlicingDirection; };



  void GenerateData();

protected:
  PerSliceImageFilter();
  ~PerSliceImageFilter() {}
  virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;


  InputImageRegionType GetInputSliceRegion(SliceNumberType slice_number) const;
  OutputImageRegionType GetOutputSliceRegion(SliceNumberType slice_number);


  InputSliceImagePointer GetInputSlice(SliceNumberType slice_number);


  void SetOutputSlice(const OutputSliceImageType * slice, SliceNumberType slice_number);


  virtual void ProcessSlice(SliceNumberType slice_number) = 0;

private:
  PerSliceImageFilter(const Self&);
  void operator=(const Self&);

  unsigned int m_SlicingDirection;
};



# 1 "../src/PerSliceImageFilter.txx" 1
# 1 "../src/PerSliceImageFilter.h" 1
# 2 "../src/PerSliceImageFilter.txx" 2
# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h" 1
# 18 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h"
#define __itkExtractImageFilter_h 



# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilterRegionCopier.h" 1
# 21 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilterRegionCopier.h"
#define __itkExtractImageFilterRegionCopier_h 



namespace itk
{

namespace ImageToImageFilterDetail
{




template <unsigned int D1, unsigned int D2>
void ExtractImageFilterCopyRegion(const typename
                                  BinaryUnsignedIntDispatch<D1, D2>::FirstEqualsSecondType &firstEqualsSecond,
                                  ImageRegion<D1> &destRegion,
                                  const ImageRegion<D2> &srcRegion,
                                  const ImageRegion<D1> &)
{
  ImageToImageFilterDefaultCopyRegion<D1, D2>(firstEqualsSecond, destRegion, srcRegion);
}






template <unsigned int D1, unsigned int D2>
void ExtractImageFilterCopyRegion(const typename
                                  BinaryUnsignedIntDispatch<D1, D2>::FirstLessThanSecondType &firstLessThanSecond,
                                  ImageRegion<D1> &destRegion,
                                  const ImageRegion<D2> &srcRegion,
                                  const ImageRegion<D1> &totalInputExtractionRegion)
{
  ImageToImageFilterDefaultCopyRegion<D1, D2>(firstLessThanSecond, destRegion, srcRegion);

}
# 77 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilterRegionCopier.h"
template <unsigned int D1, unsigned int D2>
void ExtractImageFilterCopyRegion(const typename
                                  BinaryUnsignedIntDispatch<D1, D2>::FirstGreaterThanSecondType &,
                                  ImageRegion<D1> &destRegion,
                                  const ImageRegion<D2> &srcRegion,
                                  const ImageRegion<D1> &totalInputExtractionRegion)
{



  unsigned int dim;
  Index<D1> destIndex;
  Size<D1> destSize;
  const Index<D2> &srcIndex = srcRegion.GetIndex();
  const Size<D2> &srcSize = srcRegion.GetSize();
  int count = 0;
  if (false) { } else for (dim=0; dim < D1; ++dim)
    {

    if (!totalInputExtractionRegion.GetSize()[dim])
      {
      destIndex[dim] = totalInputExtractionRegion.GetIndex()[dim];
      destSize[dim] = 1;
      }

    else
      {
      destIndex[dim] = srcIndex[count];
      destSize[dim] = srcSize[count];
      count++;
      }
    }
  destRegion.SetIndex(destIndex);
  destRegion.SetSize(destSize);
}
# 132 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilterRegionCopier.h"
template <unsigned int D1, unsigned int D2>
class ExtractImageFilterRegionCopier
  : public ImageRegionCopier<D1, D2>
{
public:
  virtual void operator()(ImageRegion<D1> &destRegion,
                          const ImageRegion<D2> &srcRegion,
                          const ImageRegion<D1> &totalInputExtractionRegion) const
  {
    ExtractImageFilterCopyRegion<D1, D2>(typename BinaryUnsignedIntDispatch<D1, D2>::ComparisonType(),
                                         destRegion, srcRegion, totalInputExtractionRegion);
  }


  virtual void operator() (ImageRegion<D1> &destRegion,
                           const ImageRegion<D2> &srcRegion) const
  {
    ImageRegionCopier<D1,D2>::operator()(destRegion, srcRegion);
  }
};



}
}
# 23 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h" 2

namespace itk
{
# 54 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h"
template <class TInputImage, class TOutputImage>
class ExtractImageFilter:
    public ImageToImageFilter<TInputImage,TOutputImage>
{
public:

  typedef ExtractImageFilter Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage> Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "ExtractImageFilter";};


  typedef TInputImage InputImageType;
  typedef TOutputImage OutputImageType;


  typedef typename TOutputImage::RegionType OutputImageRegionType;
  typedef typename TInputImage::RegionType InputImageRegionType;


  typedef typename TOutputImage::PixelType OutputImagePixelType;
  typedef typename TInputImage::PixelType InputImagePixelType;


  typedef typename TOutputImage::IndexType OutputImageIndexType;
  typedef typename TInputImage::IndexType InputImageIndexType;
  typedef typename TOutputImage::SizeType OutputImageSizeType;
  typedef typename TInputImage::SizeType InputImageSizeType;


  static const unsigned int InputImageDimension = TInputImage::ImageDimension;

  static const unsigned int OutputImageDimension = TOutputImage::ImageDimension;


  typedef
  ImageToImageFilterDetail::ExtractImageFilterRegionCopier<(Self::InputImageDimension),
                                                           (Self::OutputImageDimension)> ExtractImageFilterRegionCopierType;






  void SetExtractionRegion(InputImageRegionType extractRegion);
  virtual InputImageRegionType GetExtractionRegion () { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h" ", line " << 105 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "ExtractionRegion" " of " << this->m_ExtractionRegion << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_ExtractionRegion; };

protected:
  ExtractImageFilter();
  ~ExtractImageFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;
# 120 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h"
  virtual void GenerateOutputInformation();
# 132 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h"
  virtual void CallCopyOutputRegionToInputRegion(InputImageRegionType &destRegion,
                                                 const OutputImageRegionType &srcRegion);
# 144 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h"
  void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                            int threadId );
  InputImageRegionType m_ExtractionRegion;
  OutputImageRegionType m_OutputImageRegion;

private:
  ExtractImageFilter(const Self&);
  void operator=(const Self&);

};


}


# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx"
#define _itkExtractImageFilter_txx 

# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h" 1
# 21 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.h"
#define __itkImageRegionIterator_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h"
#define __itkImageRegionConstIterator_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.h"
#define __itkImageConstIterator_h 






namespace itk
{
# 83 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.h"
template<typename TImage>
class ImageConstIterator
{
public:

  typedef ImageConstIterator Self;





  static const unsigned int ImageIteratorDimension = TImage::ImageDimension;



  typedef typename TImage::IndexType IndexType;
  typedef typename TImage::IndexValueType IndexValueType;


  typedef typename TImage::SizeType SizeType;
  typedef typename TImage::SizeValueType SizeValueType;


  typedef typename TImage::OffsetType OffsetType;
  typedef typename TImage::OffsetValueType OffsetValueType;


  typedef typename TImage::RegionType RegionType;


  typedef TImage ImageType;




  typedef typename TImage::PixelContainer PixelContainer;
  typedef typename PixelContainer::Pointer PixelContainerPointer;


  typedef typename TImage::InternalPixelType InternalPixelType;


  typedef typename TImage::PixelType PixelType;



  typedef typename TImage::AccessorType AccessorType;



  ImageConstIterator()
    : m_Region(),
      m_PixelAccessor()
  {
    m_Image = 0;
    m_Buffer = 0;
    m_Offset = 0;
    m_BeginOffset = 0;
    m_EndOffset = 0;
  }


  virtual ~ImageConstIterator() {};



  ImageConstIterator(const Self& it)
  {
    m_Image = it.m_Image;

    m_Region = it.m_Region;

    m_Buffer = it.m_Buffer;
    m_Offset = it.m_Offset;
    m_BeginOffset = it.m_BeginOffset;
    m_EndOffset = it.m_EndOffset;
    m_PixelAccessor = it.m_PixelAccessor;
  }



  ImageConstIterator( const ImageType *ptr,
                      const RegionType &region )
  {
    m_Image = ptr;
    m_Buffer = m_Image->GetBufferPointer();
    m_Region = region;


    m_Offset = m_Image->ComputeOffset( m_Region.GetIndex() );
    m_BeginOffset = m_Offset;





    if (m_Region.GetNumberOfPixels() == 0)
      {

      m_EndOffset = m_BeginOffset;
      }
    else
      {
      IndexType ind(m_Region.GetIndex());
      SizeType size(m_Region.GetSize());
      if (false) { } else for (unsigned int i=0; i < ImageIteratorDimension; ++i)
        {
        ind[i] += (static_cast<IndexValueType>(size[i]) - 1);
        }
      m_EndOffset = m_Image->ComputeOffset( ind );
      m_EndOffset++;
      }

    m_PixelAccessor = ptr->GetPixelAccessor();
  }



  Self &operator=(const Self& it)
  {
    m_Image = it.m_Image;
    m_Region = it.m_Region;

    m_Buffer = it.m_Buffer;
    m_Offset = it.m_Offset;
    m_BeginOffset = it.m_BeginOffset;
    m_EndOffset = it.m_EndOffset;
    m_PixelAccessor = it.m_PixelAccessor;

    return *this;
  }


  static unsigned int GetImageIteratorDimension()
    {return ImageIteratorDimension;}



  bool
  operator!=(const Self &it) const
    {

    return (m_Buffer + m_Offset) != (it.m_Buffer + it.m_Offset);
    };



  bool
  operator==(const Self &it) const
    {

    return (m_Buffer + m_Offset) == (it.m_Buffer + it.m_Offset);
    };



  bool
  operator<=(const Self &it) const
    {


    return (m_Buffer + m_Offset) <= (it.m_Buffer + it.m_Offset);
    };



  bool
  operator<(const Self &it) const
    {


    return (m_Buffer + m_Offset) < (it.m_Buffer + it.m_Offset);
    };



  bool
  operator>=(const Self &it) const
    {


    return (m_Buffer + m_Offset) >= (it.m_Buffer + it.m_Offset);
    };



  bool
  operator>(const Self &it) const
    {


    return (m_Buffer + m_Offset) > (it.m_Buffer + it.m_Offset);
    };





  const IndexType GetIndex() const
    { return m_Image->ComputeIndex( static_cast<OffsetValueType>(m_Offset) ); }



  virtual void SetIndex(const IndexType &ind)
    { m_Offset = m_Image->ComputeOffset( ind ); }



  const RegionType& GetRegion() const
    { return m_Region; };


  const ImageType * GetImage() const
    { return m_Image.GetPointer(); };


  PixelType Get(void) const
    { return m_PixelAccessor.Get(*(m_Buffer+m_Offset)); }




  const PixelType & Value(void) const
    { return *(m_Buffer+m_Offset); }





  Self Begin(void) const;



  void GoToBegin()
    {
    m_Offset = m_BeginOffset;
    };





  Self End(void) const;



  void GoToEnd()
    {
    m_Offset = m_EndOffset;
    };



  bool IsAtBegin(void) const
    {
    return (m_Offset == m_BeginOffset);
    }



  bool IsAtEnd(void) const
    {
    return (m_Offset == m_EndOffset);
    }


protected:
  typename TImage::ConstWeakPointer m_Image;
  RegionType m_Region;

  unsigned long m_Offset;
  unsigned long m_BeginOffset;
  unsigned long m_EndOffset;

  const InternalPixelType * m_Buffer;

  AccessorType m_PixelAccessor;
};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.txx"
#define _itkImageConstIterator_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.txx" 2

namespace itk
{



template<class TImage>
ImageConstIterator<TImage>
ImageConstIterator<TImage>
::Begin() const
{

  Self it( *this );


  it.m_Offset = m_BeginOffset;

  return it;
}
# 49 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.txx"
template<class TImage>
ImageConstIterator<TImage>
ImageConstIterator<TImage>
::End() const
{

  Self it( *this );


  it.m_Offset = m_EndOffset;

  return it;
}

}
# 366 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIterator.h" 2
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.h"
#define __itkImageIterator_h 



namespace itk
{
# 62 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.h"
template<typename TImage>
class ImageIterator : public ImageConstIterator<TImage>
{
public:

  typedef ImageIterator Self;





  static const unsigned int ImageIteratorDimension = TImage::ImageDimension;



  typedef ImageConstIterator<TImage> Superclass;


  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::IndexValueType IndexValueType;
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;
  typedef typename Superclass::OffsetType OffsetType;
  typedef typename Superclass::OffsetValueType OffsetValueType;
  typedef typename Superclass::RegionType RegionType;
  typedef typename Superclass::ImageType ImageType;
  typedef typename Superclass::PixelContainer PixelContainer;
  typedef typename Superclass::PixelContainerPointer PixelContainerPointer;
  typedef typename Superclass::InternalPixelType InternalPixelType;
  typedef typename Superclass::PixelType PixelType;
  typedef typename Superclass::AccessorType AccessorType;




  ImageIterator();


  ~ImageIterator() {};




  ImageIterator(const Self& it);



  ImageIterator(TImage *ptr, const RegionType& region);



  Self &operator=(const Self& it);


  void Set( const PixelType & value) const
    { this->m_PixelAccessor.Set(*(const_cast<InternalPixelType *>(this->m_Buffer)+this->m_Offset),value); }




  PixelType & Value(void)
    { return *(const_cast<InternalPixelType *>(this->m_Buffer)+this->m_Offset); }




  Self Begin(void) const;




  Self End(void) const;


  ImageType * GetImage() const
    { return const_cast<ImageType *>( this->m_Image.GetPointer() ); };


protected:


  ImageIterator(const ImageConstIterator<TImage> & it);
  Self &operator=(const ImageConstIterator<TImage> & it);
};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.txx"
#define _itkImageIterator_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.txx" 2

namespace itk
{






template<class TImage>
ImageIterator<TImage>
::ImageIterator()
{
}






template<class TImage>
ImageIterator<TImage>
::ImageIterator(const Self& it):
  ImageConstIterator<TImage>(it)
{
}






template<class TImage>
ImageIterator<TImage>
::ImageIterator(TImage *ptr, const RegionType & region ):
  ImageConstIterator<TImage>( ptr, region )
{
}





template<class TImage>
ImageIterator<TImage>
::ImageIterator(const ImageConstIterator<TImage> & it):
  ImageConstIterator<TImage>( it )
{
}






template<class TImage>
ImageIterator<TImage> &
ImageIterator<TImage>
::operator=(const ImageConstIterator<TImage> & it)
{
  this->ImageConstIterator<TImage>::operator=( it );
  return *this;
}






template<class TImage>
ImageIterator<TImage> &
ImageIterator<TImage>
::operator=(const Self& it)
{
  this->ImageConstIterator<TImage>::operator=( it );
  return *this;
}





template<class TImage>
ImageIterator<TImage>
ImageIterator<TImage>
::Begin() const
{
  return this->Superclass::Begin();
}
# 119 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.txx"
template<class TImage>
ImageIterator<TImage>
ImageIterator<TImage>
::End() const
{
  return this->Superclass::End();
}




}
# 151 "/tmp/installed/include/InsightToolkit/Common/itkImageIterator.h" 2
# 22 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h" 2

namespace itk
{
# 103 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h"
template<typename TImage>
class ImageRegionConstIterator : public ImageConstIterator<TImage>
{
public:

  typedef ImageRegionConstIterator Self;
  typedef ImageConstIterator<TImage> Superclass;





  static const unsigned int ImageIteratorDimension = Superclass::ImageIteratorDimension;




  typedef typename Superclass::IndexType IndexType;



  typedef typename Superclass::SizeType SizeType;


  typedef typename Superclass::RegionType RegionType;



  typedef typename Superclass::ImageType ImageType;




  typedef typename Superclass::PixelContainer PixelContainer;
  typedef typename Superclass::PixelContainerPointer PixelContainerPointer;


  typedef typename Superclass::InternalPixelType InternalPixelType;


  typedef typename Superclass::PixelType PixelType;



  typedef typename Superclass::AccessorType AccessorType;


  virtual const char *GetNameOfClass() const {return "ImageRegionConstIterator";};


  ImageRegionConstIterator() : ImageConstIterator<TImage>()
  {
    this->m_SpanBeginOffset = 0;
    this->m_SpanEndOffset = 0;
  }



  ImageRegionConstIterator(const ImageType *ptr,
                      const RegionType &region)
    : ImageConstIterator<TImage>(ptr, region)
  {
    this->m_SpanBeginOffset = this->m_BeginOffset;
    this->m_SpanEndOffset = this->m_BeginOffset + static_cast<long>(this->m_Region.GetSize()[0]);
  }







  ImageRegionConstIterator( const ImageIterator<TImage> &it)
  {
    this->ImageIterator<TImage>::operator=(it);
    IndexType ind = this->GetIndex();
    this->m_SpanEndOffset = this->m_Offset + static_cast<long>(this->m_Region.GetSize()[0])
      - (ind[0] - this->m_Region.GetIndex()[0]);
    this->m_SpanBeginOffset = this->m_SpanEndOffset
      - static_cast<long>(this->m_Region.GetSize()[0]);
  }







  ImageRegionConstIterator( const ImageConstIterator<TImage> &it)
  {
    this->ImageConstIterator<TImage>::operator=(it);
    IndexType ind = this->GetIndex();
    this->m_SpanEndOffset = this->m_Offset + static_cast<long>(this->m_Region.GetSize()[0])
      - (ind[0] - this->m_Region.GetIndex()[0]);
    this->m_SpanBeginOffset = this->m_SpanEndOffset
      - static_cast<long>(this->m_Region.GetSize()[0]);
  }



  void GoToBegin()
  {
    Superclass::GoToBegin();


    this->m_SpanBeginOffset = this->m_BeginOffset;
    this->m_SpanEndOffset = this->m_BeginOffset
      + static_cast<long>(this->m_Region.GetSize()[0]);
  };



  void GoToEnd()
  {
    Superclass::GoToEnd();


    this->m_SpanEndOffset = this->m_EndOffset;
    this->m_SpanBeginOffset = this->m_SpanEndOffset
      - static_cast<long>(this->m_Region.GetSize()[0]);
  };




  Self Begin(void) const;




  Self End(void) const;





  void SetIndex(const IndexType &ind)
  { Superclass::SetIndex(ind);
    this->m_SpanEndOffset = this->m_Offset + static_cast<long>(this->m_Region.GetSize()[0])
      - (ind[0] - this->m_Region.GetIndex()[0]);
    this->m_SpanBeginOffset = this->m_SpanEndOffset
      - static_cast<long>(this->m_Region.GetSize()[0]);
  }
# 254 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h"
  Self &
  operator++()
  {
    if (++this->m_Offset >= this->m_SpanEndOffset)
      {




      --this->m_Offset;


      typename ImageIterator<TImage>::IndexType
        ind = this->m_Image->ComputeIndex( static_cast<typename Superclass::OffsetValueType>(this->m_Offset) );

      const typename ImageIterator<TImage>::IndexType&
        startIndex = this->m_Region.GetIndex();
      const typename ImageIterator<TImage>::SizeType&
        size = this->m_Region.GetSize();


      unsigned int dim;



      bool done = (++ind[0] == startIndex[0] + static_cast<typename Superclass::IndexValueType>(size[0]));
      if (false) { } else for (unsigned int i=1; done && i < ImageIteratorDimension; i++)
        {
        done = (ind[i] == startIndex[i] + static_cast<typename Superclass::IndexValueType>(size[i]) - 1);
        }



      dim = 0;
      if (!done)
        {
        while ( ( dim+1 < ImageIteratorDimension )
          && (ind[dim] > startIndex[dim] + static_cast<typename Superclass::IndexValueType>(size[dim]) - 1) )
          {
          ind[dim] = startIndex[dim];
          ind[++dim]++;
          }
        }
      this->m_Offset = this->m_Image->ComputeOffset( ind );
      this->m_SpanEndOffset = this->m_Offset + static_cast<long>(size[0]);
      this->m_SpanBeginOffset = this->m_Offset;
      }
    return *this;
  }
# 311 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h"
  Self & operator--()
  {
    if (--this->m_Offset < this->m_SpanBeginOffset)
      {




      this->m_Offset++;


      typename ImageIterator<TImage>::IndexType
        ind = this->m_Image->ComputeIndex( static_cast<typename Superclass::IndexValueType>(this->m_Offset) );

      const typename ImageIterator<TImage>::IndexType&
        startIndex = this->m_Region.GetIndex();
      const typename ImageIterator<TImage>::SizeType&
        size = this->m_Region.GetSize();


      bool done;
      unsigned int dim;



      done = (--ind[0] == startIndex[0] - 1);
      if (false) { } else for (unsigned int i=1; done && i < ImageIteratorDimension; i++)
        {
        done = (ind[i] == startIndex[i]);
        }



      dim = 0;
      if (!done)
        {
        while ( (dim < ImageIteratorDimension - 1)
                && (ind[dim] < startIndex[dim]) )
          {
          ind[dim] = startIndex[dim] + static_cast<typename Superclass::IndexValueType>(size[dim]) - 1;
          ind[++dim]--;
          }
        }
      this->m_Offset = this->m_Image->ComputeOffset( ind );
      this->m_SpanEndOffset = this->m_Offset + 1;
      this->m_SpanBeginOffset = this->m_SpanEndOffset - static_cast<long>(size[0]);
      }
    return *this;
  }

protected:
  unsigned long m_SpanBeginOffset;
  unsigned long m_SpanEndOffset;

};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.txx"
#define _itkImageRegionConstIterator_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.txx" 2

namespace itk
{



template<class TImage>
ImageRegionConstIterator<TImage>
ImageRegionConstIterator<TImage>
::Begin() const
{

  Self it( *this );


  it.GoToBegin();

  return it;
}
# 49 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.txx"
template<class TImage>
ImageRegionConstIterator<TImage>
ImageRegionConstIterator<TImage>
::End() const
{

  Self it( *this );


  it.GoToEnd();

  return it;
}

}
# 371 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIterator.h" 2
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.h"
#define __itkImageIteratorWithIndex_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.h"
#define __itkImageConstIteratorWithIndex_h 





namespace itk
{
# 90 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.h"
template<typename TImage>
class ImageConstIteratorWithIndex
{
public:

  typedef ImageConstIteratorWithIndex Self;





  static const unsigned int ImageDimension = TImage::ImageDimension;


  typedef typename TImage::IndexType IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;


  typedef typename TImage::SizeType SizeType;
  typedef typename SizeType::SizeValueType SizeValueType;


  typedef typename TImage::RegionType RegionType;


  typedef TImage ImageType;




  typedef typename TImage::PixelContainer PixelContainer;
  typedef typename PixelContainer::Pointer PixelContainerPointer;


  typedef typename TImage::InternalPixelType InternalPixelType;


  typedef typename TImage::PixelType PixelType;



  typedef typename TImage::AccessorType AccessorType;


  typedef typename TImage::OffsetType OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;



  ImageConstIteratorWithIndex();



  ImageConstIteratorWithIndex(const Self& it);



  ImageConstIteratorWithIndex( const TImage *ptr,
                               const RegionType& region );



  Self &operator=(const Self& it);


  static unsigned int GetImageDimension()
    {return ImageDimension;}



  bool
  operator!=(const Self &it) const
    {

    return (m_Position) != (it.m_Position);
    };



  bool
  operator==(const Self &it) const
    {

    return (m_Position) == (it.m_Position);
    };



  bool
  operator<=(const Self &it) const
    {


    return (m_Position) <= (it.m_Position);
    };



  bool
  operator<(const Self &it) const
    {


    return (m_Position) < (it.m_Position);
    };



  bool
  operator>=(const Self &it) const
    {


    return (m_Position) >= (it.m_Position);
    };



  bool
  operator>(const Self &it) const
    {


    return (m_Position) > (it.m_Position);
    };



  const IndexType GetIndex()
    { return m_PositionIndex; }



  const RegionType& GetRegion() const
    { return m_Region; };



  void SetIndex(const IndexType &ind)
    { m_Position = m_Begin + m_Image->ComputeOffset( ind );
      m_PositionIndex = ind; }


  PixelType Get(void) const
    { return m_PixelAccessor.Get(*m_Position); }




  const PixelType & Value(void) const
    { return *m_Position; }



  Self Begin(void) const;


  void GoToBegin(void);



  Self End(void) const;


  void GoToReverseBegin(void);


  bool IsAtReverseEnd(void) const
    {
      return !m_Remaining;
    }


  bool IsAtEnd(void) const
    {
      return !m_Remaining;
    }


  bool Remaining()
    {
    return m_Remaining;
    }

protected:
  typename TImage::ConstWeakPointer m_Image;

  IndexType m_PositionIndex;
  IndexType m_BeginIndex;
  IndexType m_EndIndex;



  RegionType m_Region;

  unsigned long m_OffsetTable[ ImageDimension + 1 ];

  const InternalPixelType *m_Position;
  const InternalPixelType *m_Begin;
  const InternalPixelType *m_End;

  bool m_Remaining;

  AccessorType m_PixelAccessor;

};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.txx"
#define _itkImageConstIteratorWithIndex_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.txx" 2

namespace itk
{






template<class TImage>
ImageConstIteratorWithIndex<TImage>
::ImageConstIteratorWithIndex()
{
  m_Position = 0;
  m_Begin = 0;
  m_End = 0;
  m_Remaining = false;
}






template<class TImage>
ImageConstIteratorWithIndex<TImage>
::ImageConstIteratorWithIndex(const Self& it)
{
  m_Image = it.m_Image;

  m_PositionIndex = it.m_PositionIndex;
  m_BeginIndex = it.m_BeginIndex;
  m_EndIndex = it.m_EndIndex;
  m_Region = it.m_Region;

  memcpy(m_OffsetTable, it.m_OffsetTable,
         (ImageDimension+1)*sizeof(unsigned long));

  m_Position = it.m_Position;
  m_Begin = it.m_Begin;
  m_End = it.m_End;
  m_Remaining = it.m_Remaining;

  m_PixelAccessor = it.m_PixelAccessor;
}






template<class TImage>
ImageConstIteratorWithIndex<TImage>
::ImageConstIteratorWithIndex( const TImage *ptr,
                               const RegionType & region )
{
  m_Image = ptr;

  const InternalPixelType * buffer = m_Image->GetBufferPointer();

  m_BeginIndex = region.GetIndex();
  m_PositionIndex = m_BeginIndex;
  m_Region = region;

  memcpy(m_OffsetTable, m_Image->GetOffsetTable(),
         (ImageDimension+1)*sizeof(unsigned long));


  long offs = m_Image->ComputeOffset( m_BeginIndex );
  m_Begin = buffer + offs;
  m_Position = m_Begin;


  m_Remaining = false;
  IndexType pastEnd;
  if (false) { } else for (unsigned int i=0; i < ImageDimension; ++i)
    {
    unsigned long size = region.GetSize()[i];
    if( size > 0 )
      {
      m_Remaining = true;
      }
    m_EndIndex[i] = m_BeginIndex[i] + static_cast<long>(size);
    pastEnd[i] = m_BeginIndex[i] + static_cast<long>(size)-1;
    }
  m_End = buffer + m_Image->ComputeOffset( pastEnd );

  m_PixelAccessor = m_Image->GetPixelAccessor();

  GoToBegin();

}





template<class TImage>
ImageConstIteratorWithIndex<TImage> &
ImageConstIteratorWithIndex<TImage>
::operator=(const Self& it)
{
  m_Image = it.m_Image;

  m_BeginIndex = it.m_BeginIndex;
  m_EndIndex = it.m_EndIndex;
  m_PositionIndex = it.m_PositionIndex;
  m_Region = it.m_Region;

  memcpy(m_OffsetTable, it.m_OffsetTable,
         (ImageDimension+1)*sizeof(unsigned long));

  m_Position = it.m_Position;
  m_Begin = it.m_Begin;
  m_End = it.m_End;
  m_Remaining = it.m_Remaining;

  m_PixelAccessor = it.m_PixelAccessor;

  return *this;
}






template<class TImage>
ImageConstIteratorWithIndex<TImage>
ImageConstIteratorWithIndex<TImage>
::Begin() const
{
  Self it( *this );
  it.GoToBegin();
  return it;
}





template<class TImage>
void
ImageConstIteratorWithIndex<TImage>
::GoToBegin()
{


  m_Position = m_Begin;
  m_PositionIndex = m_BeginIndex;

  if( m_Region.GetNumberOfPixels() > 0 )
    {
    m_Remaining = true;
    }
  else
    {
    m_Remaining = false;
    }

}





template<class TImage>
ImageConstIteratorWithIndex<TImage>
ImageConstIteratorWithIndex<TImage>
::End() const
{
  Self it( *this );
  it.GoToReverseBegin();
  return it;
}





template<class TImage>
void
ImageConstIteratorWithIndex<TImage>
::GoToReverseBegin()
{

  if (false) { } else for (unsigned int i=0; i < ImageDimension; ++i)
    {
    m_PositionIndex[i] = m_EndIndex[i]-1;
    }

  if( m_Region.GetNumberOfPixels() > 0 )
    {
    m_Remaining = true;
    }
  else
    {
    m_Remaining = false;
    }



  const InternalPixelType * buffer = m_Image->GetBufferPointer();
  const unsigned long offset = m_Image->ComputeOffset( m_PositionIndex );
  m_Position = buffer + offset;

}


}
# 301 "/tmp/installed/include/InsightToolkit/Common/itkImageConstIteratorWithIndex.h" 2
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.h" 2

namespace itk
{
# 66 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.h"
template<typename TImage>
class ImageIteratorWithIndex : public ImageConstIteratorWithIndex<TImage>
{
public:

  typedef ImageIteratorWithIndex Self;





  static const unsigned int ImageIteratorDimension = TImage::ImageDimension;



  typedef ImageConstIteratorWithIndex<TImage> Superclass;


  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::IndexValueType IndexValueType;
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;
  typedef typename Superclass::OffsetType OffsetType;
  typedef typename Superclass::OffsetValueType OffsetValueType;
  typedef typename Superclass::RegionType RegionType;
  typedef typename Superclass::ImageType ImageType;
  typedef typename Superclass::PixelContainer PixelContainer;
  typedef typename Superclass::PixelContainerPointer PixelContainerPointer;
  typedef typename Superclass::InternalPixelType InternalPixelType;
  typedef typename Superclass::PixelType PixelType;
  typedef typename Superclass::AccessorType AccessorType;




  ImageIteratorWithIndex();


  ~ImageIteratorWithIndex() {};




  ImageIteratorWithIndex(const Self& it);



  ImageIteratorWithIndex(TImage *ptr, const RegionType& region);



  Self &operator=(const Self& it);


  void Set( const PixelType & value) const
    { this->m_PixelAccessor.Set(*(const_cast<InternalPixelType *>(this->m_Position)),value); }




  PixelType & Value(void)
    { return *(const_cast<InternalPixelType *>(this->m_Position)); }

protected:


  ImageIteratorWithIndex(const ImageConstIteratorWithIndex<TImage> & it);
  Self &operator=(const ImageConstIteratorWithIndex<TImage> & it);
};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.txx"
#define _itkImageIteratorWithIndex_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.txx" 2

namespace itk
{






template<class TImage>
ImageIteratorWithIndex<TImage>
::ImageIteratorWithIndex()
{
}






template<class TImage>
ImageIteratorWithIndex<TImage>
::ImageIteratorWithIndex(const Self& it):
  ImageConstIteratorWithIndex<TImage>(it)
{
}






template<class TImage>
ImageIteratorWithIndex<TImage>
::ImageIteratorWithIndex(TImage *ptr, const RegionType & region ):
  ImageConstIteratorWithIndex<TImage>( ptr, region )
{
}





template<class TImage>
ImageIteratorWithIndex<TImage>
::ImageIteratorWithIndex(const ImageConstIteratorWithIndex<TImage> & it):
  ImageConstIteratorWithIndex<TImage>( it )
{
}






template<class TImage>
ImageIteratorWithIndex<TImage> &
ImageIteratorWithIndex<TImage>
::operator=(const ImageConstIteratorWithIndex<TImage> & it)
{
  this->ImageConstIteratorWithIndex<TImage>::operator=( it );
  return *this;
}






template<class TImage>
ImageIteratorWithIndex<TImage> &
ImageIteratorWithIndex<TImage>
::operator=(const Self& it)
{
  this->ImageConstIteratorWithIndex<TImage>::operator=( it );
  return *this;
}





}
# 140 "/tmp/installed/include/InsightToolkit/Common/itkImageIteratorWithIndex.h" 2
# 22 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.h" 2

namespace itk
{
# 72 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.h"
template<typename TImage>
class ImageRegionIterator : public ImageRegionConstIterator<TImage>
{
public:

  typedef ImageRegionIterator Self;
  typedef ImageRegionConstIterator<TImage> Superclass;


  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::IndexValueType IndexValueType;
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;
  typedef typename Superclass::OffsetType OffsetType;
  typedef typename Superclass::OffsetValueType OffsetValueType;
  typedef typename Superclass::RegionType RegionType;
  typedef typename Superclass::ImageType ImageType;
  typedef typename Superclass::PixelContainer PixelContainer;
  typedef typename Superclass::PixelContainerPointer PixelContainerPointer;
  typedef typename Superclass::InternalPixelType InternalPixelType;
  typedef typename Superclass::PixelType PixelType;
  typedef typename Superclass::AccessorType AccessorType;



  ImageRegionIterator();



  ImageRegionIterator(ImageType *ptr, const RegionType& region);







  ImageRegionIterator( const ImageIteratorWithIndex<TImage> &it);


  void Set( const PixelType & value) const
    { this->m_PixelAccessor.Set(*(const_cast<InternalPixelType *>(this->m_Buffer+this->m_Offset)),value); }




  PixelType & Value(void)
    { return *(const_cast<InternalPixelType *>(this->m_Buffer+this->m_Offset)); }




  Self Begin(void) const;




  Self End(void) const;


protected:


  ImageRegionIterator( const ImageRegionConstIterator<TImage> &it);
  Self & operator=(const ImageRegionConstIterator<TImage> & it);


};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.txx"
#define _itkImageRegionIterator_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.txx" 2

namespace itk
{



template< typename TImage >
ImageRegionIterator<TImage>
::ImageRegionIterator()
  : ImageRegionConstIterator<TImage>()
{


}



template< typename TImage >
ImageRegionIterator<TImage>
::ImageRegionIterator(ImageType *ptr, const RegionType& region) :
  ImageRegionConstIterator<TImage>( ptr, region )
{


}



template< typename TImage >
ImageRegionIterator<TImage>
::ImageRegionIterator( const ImageIteratorWithIndex<TImage> &it):
  ImageRegionConstIterator<TImage>(it)
{
}


template< typename TImage >
ImageRegionIterator<TImage>
::ImageRegionIterator( const ImageRegionConstIterator<TImage> &it):
  ImageRegionConstIterator<TImage>(it)
{
}


template< typename TImage >
ImageRegionIterator<TImage> &
ImageRegionIterator<TImage>
::operator=( const ImageRegionConstIterator<TImage> &it)
{
  this->ImageRegionConstIterator<TImage>::operator=(it);
  return *this;
}



template< typename TImage >
ImageRegionIterator<TImage>
ImageRegionIterator<TImage>
::Begin() const
{
  return this->Superclass::Begin();
}




template< typename TImage >
ImageRegionIterator<TImage>
ImageRegionIterator<TImage>
::End() const
{
  return this->Superclass::End();
}




}
# 145 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIterator.h" 2
# 22 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx" 2



# 1 "/tmp/installed/include/InsightToolkit/Common/itkProgressReporter.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkProgressReporter.h"
#define _itkProgressReporter_h 



namespace itk
{
# 58 "/tmp/installed/include/InsightToolkit/Common/itkProgressReporter.h"
class ProgressReporter
{
public:

  ProgressReporter(ProcessObject* filter, int threadId,
                   unsigned long numberOfPixels,
                   unsigned long numberOfUpdates = 100,
                   float initialProgress = 0.0f,
                   float progressWeight = 1.0f );


  ~ProgressReporter();


  void CompletedPixel()
    {




    if(--m_PixelsBeforeUpdate == 0)
      {
      m_PixelsBeforeUpdate = m_PixelsPerUpdate;
      m_CurrentPixel += m_PixelsPerUpdate;
      m_Filter->UpdateProgress(
          m_CurrentPixel * m_InverseNumberOfPixels * m_ProgressWeight + m_InitialProgress);
      if( m_Filter->GetAbortGenerateData() )
        {
        throw ProcessAborted();
        }
      }
    }

protected:
  ProcessObject* m_Filter;
  int m_ThreadId;
  float m_InverseNumberOfPixels;
  unsigned long m_CurrentPixel;
  unsigned long m_PixelsPerUpdate;
  unsigned long m_PixelsBeforeUpdate;
  float m_InitialProgress;
  float m_ProgressWeight;

private:
  ProgressReporter();

};

}
# 26 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx" 2


namespace itk
{




template <class TInputImage, class TOutputImage>
ExtractImageFilter<TInputImage,TOutputImage>
::ExtractImageFilter()
{
}





template <class TInputImage, class TOutputImage>
void
ExtractImageFilter<TInputImage,TOutputImage>
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  os << indent << "ExtractionRegion: " << m_ExtractionRegion << std::endl;
  os << indent << "OutputImageRegion: " << m_OutputImageRegion << std::endl;
}


template<class TInputImage, class TOutputImage>
void
ExtractImageFilter<TInputImage,TOutputImage>
::CallCopyOutputRegionToInputRegion(InputImageRegionType &destRegion,
                                    const OutputImageRegionType &srcRegion)
{
  ExtractImageFilterRegionCopierType extractImageRegionCopier;
  extractImageRegionCopier(destRegion, srcRegion, m_ExtractionRegion);
}


template <class TInputImage, class TOutputImage>
void
ExtractImageFilter<TInputImage,TOutputImage>
::SetExtractionRegion(InputImageRegionType extractRegion)
{
  m_ExtractionRegion = extractRegion;

  unsigned int nonzeroSizeCount = 0;
  InputImageSizeType inputSize = extractRegion.GetSize();
  OutputImageSizeType outputSize;
  OutputImageIndexType outputIndex;





  if (false) { } else for (unsigned int i = 0; i < InputImageDimension; ++i)
    {
    if (inputSize[i])
      {
      outputSize[nonzeroSizeCount] = inputSize[i];
      outputIndex[nonzeroSizeCount] = extractRegion.GetIndex()[i];
      nonzeroSizeCount++;
      }
    }

  if (nonzeroSizeCount != OutputImageDimension)
    {
    { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " "Extraction Region not consistent with output image"; ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx", 95, message.str().c_str()); throw e_; };
    }

  m_OutputImageRegion.SetSize(outputSize);
  m_OutputImageRegion.SetIndex(outputIndex);
  this->Modified();
}
# 114 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx"
template <class TInputImage, class TOutputImage>
void
ExtractImageFilter<TInputImage,TOutputImage>
::GenerateOutputInformation()
{




  typename Superclass::OutputImagePointer outputPtr = this->GetOutput();
  typename Superclass::InputImageConstPointer inputPtr = this->GetInput();

  if ( !outputPtr || !inputPtr)
    {
    return;
    }


  outputPtr->SetLargestPossibleRegion( m_OutputImageRegion );


  const ImageBase<InputImageDimension> *phyData;

  phyData
    = dynamic_cast<const ImageBase<InputImageDimension>*>(this->GetInput());

  if (phyData)
    {



    unsigned int i;
    const typename InputImageType::SpacingType&
      inputSpacing = inputPtr->GetSpacing();
    const typename InputImageType::PointType&
      inputOrigin = inputPtr->GetOrigin();

    typename OutputImageType::SpacingType outputSpacing;
    typename OutputImageType::PointType outputOrigin;

    if ( static_cast<unsigned int>(OutputImageDimension) >
         static_cast<unsigned int>(InputImageDimension ) )
      {


      if (false) { } else for (i=0; i < InputImageDimension; ++i)
        {
        outputSpacing[i] = inputSpacing[i];
        outputOrigin[i] = inputOrigin[i];
        }
      if (false) { } else for (; i < OutputImageDimension; ++i)
        {
        outputSpacing[i] = 1.0;
        outputOrigin[i] = 0.0;
        }
      }
    else
      {

      int nonZeroCount = 0;
      if (false) { } else for (i=0; i < InputImageDimension; ++i)
        {
        if (m_ExtractionRegion.GetSize()[i])
          {
          outputSpacing[nonZeroCount] = inputSpacing[i];
          outputOrigin[nonZeroCount] = inputOrigin[i];
          nonZeroCount++;
          }
        }
      }


    outputPtr->SetSpacing( outputSpacing );
    outputPtr->SetOrigin( outputOrigin );
    }
  else
    {

    { ::itk::OStringStream message; message << "itk::ERROR: " << this->GetNameOfClass() << "(" << this << "): " << "itk::ExtractImageFilter::GenerateOutputInformation " << "cannot cast input to " << typeid(ImageBase<InputImageDimension>*).name(); ::itk::ExceptionObject e_("/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx", 194, message.str().c_str()); throw e_; };


    }
}
# 210 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx"
template <class TInputImage, class TOutputImage>
void
ExtractImageFilter<TInputImage,TOutputImage>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                       int threadId)
{
  { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.txx" ", line " << 216 << "\n" << this->GetNameOfClass() << " (" << this << "): " <<"Actually executing" << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} };


  typename Superclass::InputImageConstPointer inputPtr = this->GetInput();
  typename Superclass::OutputImagePointer outputPtr = this->GetOutput();


  ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels());


  InputImageRegionType inputRegionForThread;
  this->CallCopyOutputRegionToInputRegion(inputRegionForThread, outputRegionForThread);


  typedef ImageRegionIterator<TOutputImage> OutputIterator;
  typedef ImageRegionConstIterator<TInputImage> InputIterator;

  OutputIterator outIt(outputPtr, outputRegionForThread);
  InputIterator inIt(inputPtr, inputRegionForThread);


  while( !outIt.IsAtEnd() )
    {

    outIt.Set( inIt.Get());
    ++outIt;
    ++inIt;
    progress.CompletedPixel();
    }
}

}
# 160 "/tmp/installed/include/InsightToolkit/BasicFilters/itkExtractImageFilter.h" 2
# 3 "../src/PerSliceImageFilter.txx" 2



template <class TInputImage, class TOutputImage>
PerSliceImageFilter<TInputImage, TOutputImage>
::PerSliceImageFilter()
  : Superclass(), m_SlicingDirection(InputImageDimension-1)
{
}


template <class TInputImage, class TOutputImage>
void
PerSliceImageFilter<TInputImage, TOutputImage>
::GenerateData()
{


  SliceNumberType slice_count = this->GetInput()->GetLargestPossibleRegion().GetSize(this->m_SlicingDirection);
  if (false) { } else for (SliceNumberType slice = 0; slice < slice_count; ++slice)
    this->ProcessSlice(slice);
}


template <class TInputImage, class TOutputImage>
typename PerSliceImageFilter<TInputImage, TOutputImage>::InputImageRegionType
PerSliceImageFilter<TInputImage, TOutputImage>
::GetInputSliceRegion(SliceNumberType slice_number) const
{



  InputImageRegionType region(this->GetInput()->GetLargestPossibleRegion());
  region.SetSize(this->m_SlicingDirection, 1);
  region.SetIndex(this->m_SlicingDirection, slice_number);

  return region;
}


template <class TInputImage, class TOutputImage>
typename PerSliceImageFilter<TInputImage, TOutputImage>::OutputImageRegionType
PerSliceImageFilter<TInputImage, TOutputImage>
::GetOutputSliceRegion(SliceNumberType slice_number)
{



  OutputImageRegionType region(this->GetOutput()->GetLargestPossibleRegion());
  region.SetSize(this->m_SlicingDirection, 1);
  region.SetIndex(this->m_SlicingDirection, slice_number);

  return region;
}


template <class TInputImage, class TOutputImage>
typename PerSliceImageFilter<TInputImage, TOutputImage>::InputSliceImagePointer
PerSliceImageFilter<TInputImage, TOutputImage>
::GetInputSlice(SliceNumberType slice_number)
{
  typedef itk::ExtractImageFilter<InputImageType, InputSliceImageType> ExtractorType;
  typename ExtractorType::Pointer extractor = ExtractorType::New();
  extractor->SetInput(this->GetInput());
  InputImageRegionType region(this->GetInputSliceRegion(slice_number));
  region.SetSize(this->m_SlicingDirection, 0);
  extractor->SetExtractionRegion(region);
  extractor->Update();
  return extractor->GetOutput();
}


template <class TInputImage, class TOutputImage>
void
PerSliceImageFilter<TInputImage, TOutputImage>
::SetOutputSlice(const OutputSliceImageType * slice, SliceNumberType slice_number)
{





  typedef itk::ImageRegionIterator<const OutputSliceImageType> SliceIterator;
  typedef itk::ImageRegionIterator<OutputImageType> ImageIterator;

  ImageIterator oit(this->GetOutput(), this->GetOutputSliceRegion(slice_number));
  SliceIterator sit(slice, slice->GetLargestPossibleRegion());
  if (false) { } else for (oit.GoToBegin(), sit.GoToBegin(); !oit.IsAtEnd(); ++oit, ++sit)
    oit.Set(sit.Get());
}


template <class TInputImage, class TOutputImage>
void
PerSliceImageFilter<TInputImage, TOutputImage>
::PrintSelf(std::ostream& os, itk::Indent indent) const
{

  Superclass::PrintSelf(os, indent);


  os << indent << "SlicingDirection: "
     << static_cast<typename itk::NumericTraits<unsigned int>::PrintType>(this->m_SlicingDirection) << std::endl;
}
# 102 "../src/PerSliceImageFilter.h" 2
# 6 "../src/PerSliceConnectedComponentImageFilter.h" 2


template <class TInputImage, class TOutputImage>
class PerSliceConnectedComponentImageFilter
  : public PerSliceImageFilter<TInputImage, TOutputImage>
{
public:

  typedef PerSliceConnectedComponentImageFilter<TInputImage, TOutputImage> Self;
  typedef PerSliceImageFilter<TInputImage, TOutputImage> Superclass;
  typedef itk::SmartPointer<Self> Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual const char *GetNameOfClass() const {return "PerSliceConnectedComponentImageFilter";};


  typedef typename Superclass::InputImageType InputImageType;
  typedef typename Superclass::InputImagePointer InputImagePointer;
  typedef typename Superclass::InputImageConstPointer InputImageConstPointer;
  typedef typename Superclass::InputImageRegionType InputImageRegionType;
  typedef typename Superclass::InputImagePixelType InputImagePixelType;
  typedef typename Superclass::OutputImageType OutputImageType;

  typedef typename Superclass::OutputImageRegionType OutputImageRegionType;



  typedef typename Superclass::SliceNumberType SliceNumberType;


  typedef typename Superclass::InputSliceImageType InputSliceImageType;
  typedef typename Superclass::InputSliceImagePointer InputSliceImagePointer;
  typedef typename Superclass::OutputSliceImageType OutputSliceImageType;


  typedef typename Superclass::InputPixelType InputPixelType;
  typedef typename Superclass::OutputPixelType OutputPixelType;

protected:
  PerSliceConnectedComponentImageFilter();
  ~PerSliceConnectedComponentImageFilter() {}


  virtual void ProcessSlice(SliceNumberType slice_number);

private:
  PerSliceConnectedComponentImageFilter(const Self&);
  void operator=(const Self&);
};



# 1 "../src/PerSliceConnectedComponentImageFilter.txx" 1
# 1 "../src/PerSliceConnectedComponentImageFilter.h" 1
# 2 "../src/PerSliceConnectedComponentImageFilter.txx" 2
# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.h" 1
# 18 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.h"
#define __itkConnectedComponentImageFilter_h 




namespace itk
{
# 48 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.h"
template <class TInputImage, class TOutputImage>
class ConnectedComponentImageFilter :
    public ImageToImageFilter< TInputImage, TOutputImage >
{
public:



  typedef ConnectedComponentImageFilter Self;
  typedef ImageToImageFilter< TInputImage, TOutputImage > Superclass;




  typedef typename Superclass::InputImagePointer InputImagePointer;





  typedef typename TOutputImage::PixelType OutputPixelType;
  typedef typename TOutputImage::InternalPixelType OutputInternalPixelType;
  typedef typename TInputImage::PixelType InputPixelType;
  typedef typename TInputImage::InternalPixelType InputInternalPixelType;
  static const unsigned int ImageDimension = TOutputImage::ImageDimension;





  typedef TInputImage InputImageType;
  typedef TOutputImage OutputImageType;
  typedef typename TInputImage::IndexType IndexType;
  typedef typename TInputImage::SizeType SizeType;
  typedef typename TOutputImage::RegionType RegionType;
  typedef std::list<IndexType> ListType;




  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;




  virtual const char *GetNameOfClass() const {return "ConnectedComponentImageFilter";};




  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };







  virtual void SetFullyConnected (const bool _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.h" ", line " << 107 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " "FullyConnected" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_FullyConnected != _arg) { this->m_FullyConnected = _arg; this->Modified(); } };
  virtual bool GetFullyConnected () const { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.h" ", line " << 108 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "FullyConnected" " of " << this->m_FullyConnected << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_FullyConnected; };
  virtual void FullyConnectedOn () { this->SetFullyConnected(true);} virtual void FullyConnectedOff () { this->SetFullyConnected(false);};

protected:
  ConnectedComponentImageFilter()
    {
    m_FullyConnected = false;
    }
  virtual ~ConnectedComponentImageFilter() {}
  ConnectedComponentImageFilter(const Self&) {}
  void PrintSelf(std::ostream& os, Indent indent) const;




  void GenerateData();




  void GenerateInputRequestedRegion();





  void EnlargeOutputRequestedRegion(DataObject *);

private:

  bool m_FullyConnected;

};

}


# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.txx"
#define _itkConnectedComponentImageFilter_txx 

# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.h" 1
# 21 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.txx" 2




# 1 "/tmp/installed/include/InsightToolkit/Common/itkEquivalencyTable.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkEquivalencyTable.h"
#define __itkEquivalencyTable_h 
# 27 "/tmp/installed/include/InsightToolkit/Common/itkEquivalencyTable.h"
# 1 "/tmp/installed/include/InsightToolkit/Common/itk_hash_map.h" 1
# 55 "/tmp/installed/include/InsightToolkit/Common/itk_hash_map.h"
#define itk_emulation_hash_map_h 






# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/hash_map" 1 3
# 63 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/hash_map" 3
#define __SGI_STL_INTERNAL_HASH_MAP_H 

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/stl_hashtable.h" 1 3
# 63 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/stl_hashtable.h" 3
#define __SGI_STL_INTERNAL_HASHTABLE_H 





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iterator" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iterator" 3
#define _CPP_ITERATOR 1

       
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iterator" 3







# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stream_iterator.h" 1 3
# 36 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stream_iterator.h" 3
#define _CPP_BITS_STREAM_ITERATOR_H 1

       
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stream_iterator.h" 3

namespace std
{
  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
    class istream_iterator
      : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
    {
    public:
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

    private:
      istream_type* _M_stream;
      _Tp _M_value;
      bool _M_ok;

    public:
      istream_iterator() : _M_stream(0), _M_ok(false) {}

      istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); }

      istream_iterator(const istream_iterator& __obj)
      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
        _M_ok(__obj._M_ok)
      { }

      const _Tp&
      operator*() const { return _M_value; }

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

      istream_iterator&
      operator++()
      { _M_read(); return *this; }

      istream_iterator
      operator++(int)
      {
        istream_iterator __tmp = *this;
        _M_read();
        return __tmp;
      }

      bool
      _M_equal(const istream_iterator& __x) const
      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);}

    private:
      void
      _M_read()
      {
        _M_ok = (_M_stream && *_M_stream) ? true : false;
        if (_M_ok)
          {
            *_M_stream >> _M_value;
            _M_ok = *_M_stream ? true : false;
          }
      }
    };

  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
    inline bool
    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
               const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
    { return __x._M_equal(__y); }

  template <class _Tp, class _CharT, class _Traits, class _Dist>
    inline bool
    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
               const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
    { return !__x._M_equal(__y); }


  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT> >
    class ostream_iterator
      : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;

    private:
      ostream_type* _M_stream;
      const _CharT* _M_string;

    public:
      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}

      ostream_iterator(ostream_type& __s, const _CharT* __c)
      : _M_stream(&__s), _M_string(__c) { }

      ostream_iterator(const ostream_iterator& __obj)
      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }

      ostream_iterator&
      operator=(const _Tp& __value)
      {
        *_M_stream << __value;
        if (_M_string) *_M_stream << _M_string;
        return *this;
      }

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

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

      ostream_iterator&
      operator++(int) { return *this; }
    };
}
# 73 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/iterator" 2 3
# 70 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/stl_hashtable.h" 2 3


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/stl_hash_fun.h" 1 3
# 63 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/stl_hash_fun.h" 3
#define _CPP_BITS_STL_HASH_FUN_H 1



namespace __gnu_cxx
{
using std::size_t;

template <class _Key> struct hash { };

inline size_t __stl_hash_string(const char* __s)
{
  unsigned long __h = 0;
  if (false) { } else for ( ; *__s; ++__s)
    __h = 5*__h + *__s;

  return size_t(__h);
}

template<> struct hash<char*>
{
  size_t operator()(const char* __s) const { return __stl_hash_string(__s); }
};

template<> struct hash<const char*>
{
  size_t operator()(const char* __s) const { return __stl_hash_string(__s); }
};

template<> struct hash<char> {
  size_t operator()(char __x) const { return __x; }
};
template<> struct hash<unsigned char> {
  size_t operator()(unsigned char __x) const { return __x; }
};
template<> struct hash<signed char> {
  size_t operator()(unsigned char __x) const { return __x; }
};
template<> struct hash<short> {
  size_t operator()(short __x) const { return __x; }
};
template<> struct hash<unsigned short> {
  size_t operator()(unsigned short __x) const { return __x; }
};
template<> struct hash<int> {
  size_t operator()(int __x) const { return __x; }
};
template<> struct hash<unsigned int> {
  size_t operator()(unsigned int __x) const { return __x; }
};
template<> struct hash<long> {
  size_t operator()(long __x) const { return __x; }
};
template<> struct hash<unsigned long> {
  size_t operator()(unsigned long __x) const { return __x; }
};

}
# 73 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/stl_hashtable.h" 2 3

namespace __gnu_cxx
{
using std::size_t;
using std::ptrdiff_t;
using std::forward_iterator_tag;
using std::input_iterator_tag;
using std::_Alloc_traits;
using std::_Construct;
using std::_Destroy;
using std::distance;
using std::vector;
using std::pair;
using std::__iterator_category;

template <class _Val>
struct _Hashtable_node
{
  _Hashtable_node* _M_next;
  _Val _M_val;
};

template <class _Val, class _Key, class _HashFcn,
          class _ExtractKey, class _EqualKey, class _Alloc = std::__alloc>
class hashtable;

template <class _Val, class _Key, class _HashFcn,
          class _ExtractKey, class _EqualKey, class _Alloc>
struct _Hashtable_iterator;

template <class _Val, class _Key, class _HashFcn,
          class _ExtractKey, class _EqualKey, class _Alloc>
struct _Hashtable_const_iterator;

template <class _Val, class _Key, class _HashFcn,
          class _ExtractKey, class _EqualKey, class _Alloc>
struct _Hashtable_iterator {
  typedef hashtable<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>
          _Hashtable;
  typedef _Hashtable_iterator<_Val, _Key, _HashFcn,
                              _ExtractKey, _EqualKey, _Alloc>
          iterator;
  typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
                                    _ExtractKey, _EqualKey, _Alloc>
          const_iterator;
  typedef _Hashtable_node<_Val> _Node;

  typedef forward_iterator_tag iterator_category;
  typedef _Val value_type;
  typedef ptrdiff_t difference_type;
  typedef size_t size_type;
  typedef _Val& reference;
  typedef _Val* pointer;

  _Node* _M_cur;
  _Hashtable* _M_ht;

  _Hashtable_iterator(_Node* __n, _Hashtable* __tab)
    : _M_cur(__n), _M_ht(__tab) {}
  _Hashtable_iterator() {}
  reference operator*() const { return _M_cur->_M_val; }
  pointer operator->() const { return &(operator*()); }
  iterator& operator++();
  iterator operator++(int);
  bool operator==(const iterator& __it) const
    { return _M_cur == __it._M_cur; }
  bool operator!=(const iterator& __it) const
    { return _M_cur != __it._M_cur; }
};


template <class _Val, class _Key, class _HashFcn,
          class _ExtractKey, class _EqualKey, class _Alloc>
struct _Hashtable_const_iterator {
  typedef hashtable<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>
          _Hashtable;
  typedef _Hashtable_iterator<_Val,_Key,_HashFcn,
                              _ExtractKey,_EqualKey,_Alloc>
          iterator;
  typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
                                    _ExtractKey, _EqualKey, _Alloc>
          const_iterator;
  typedef _Hashtable_node<_Val> _Node;

  typedef forward_iterator_tag iterator_category;
  typedef _Val value_type;
  typedef ptrdiff_t difference_type;
  typedef size_t size_type;
  typedef const _Val& reference;
  typedef const _Val* pointer;

  const _Node* _M_cur;
  const _Hashtable* _M_ht;

  _Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab)
    : _M_cur(__n), _M_ht(__tab) {}
  _Hashtable_const_iterator() {}
  _Hashtable_const_iterator(const iterator& __it)
    : _M_cur(__it._M_cur), _M_ht(__it._M_ht) {}
  reference operator*() const { return _M_cur->_M_val; }
  pointer operator->() const { return &(operator*()); }
  const_iterator& operator++();
  const_iterator operator++(int);
  bool operator==(const const_iterator& __it) const
    { return _M_cur == __it._M_cur; }
  bool operator!=(const const_iterator& __it) const
    { return _M_cur != __it._M_cur; }
};


enum { __stl_num_primes = 28 };

static const unsigned long __stl_prime_list[__stl_num_primes] =
{
  53ul, 97ul, 193ul, 389ul, 769ul,
  1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
  49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
  1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
  50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
  1610612741ul, 3221225473ul, 4294967291ul
};

inline unsigned long __stl_next_prime(unsigned long __n)
{
  const unsigned long* __first = __stl_prime_list;
  const unsigned long* __last = __stl_prime_list + (int)__stl_num_primes;
  const unsigned long* pos = std::lower_bound(__first, __last, __n);
  return pos == __last ? *(__last - 1) : *pos;
}



template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
class hashtable;

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
bool operator==(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1,
                const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht2);
# 221 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/stl_hashtable.h" 3
template <class _Val, class _Key, class _HashFcn,
          class _ExtractKey, class _EqualKey, class _Alloc>
class hashtable {
public:
  typedef _Key key_type;
  typedef _Val value_type;
  typedef _HashFcn hasher;
  typedef _EqualKey key_equal;

  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;

  hasher hash_funct() const { return _M_hash; }
  key_equal key_eq() const { return _M_equals; }

private:
  typedef _Hashtable_node<_Val> _Node;

public:
  typedef typename _Alloc_traits<_Val,_Alloc>::allocator_type allocator_type;
  allocator_type get_allocator() const { return _M_node_allocator; }
private:
  typename _Alloc_traits<_Node, _Alloc>::allocator_type _M_node_allocator;
  _Node* _M_get_node() { return _M_node_allocator.allocate(1); }
  void _M_put_node(_Node* __p) { _M_node_allocator.deallocate(__p, 1); }

private:
  hasher _M_hash;
  key_equal _M_equals;
  _ExtractKey _M_get_key;
  vector<_Node*,_Alloc> _M_buckets;
  size_type _M_num_elements;

public:
  typedef _Hashtable_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>
          iterator;
  typedef _Hashtable_const_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,
                                    _Alloc>
          const_iterator;

  friend struct
  _Hashtable_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>;
  friend struct
  _Hashtable_const_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,_Alloc>;

public:
  hashtable(size_type __n,
            const _HashFcn& __hf,
            const _EqualKey& __eql,
            const _ExtractKey& __ext,
            const allocator_type& __a = allocator_type())
    : _M_node_allocator(__a),
      _M_hash(__hf),
      _M_equals(__eql),
      _M_get_key(__ext),
      _M_buckets(__a),
      _M_num_elements(0)
  {
    _M_initialize_buckets(__n);
  }

  hashtable(size_type __n,
            const _HashFcn& __hf,
            const _EqualKey& __eql,
            const allocator_type& __a = allocator_type())
    : _M_node_allocator(__a),
      _M_hash(__hf),
      _M_equals(__eql),
      _M_get_key(_ExtractKey()),
      _M_buckets(__a),
      _M_num_elements(0)
  {
    _M_initialize_buckets(__n);
  }

  hashtable(const hashtable& __ht)
    : _M_node_allocator(__ht.get_allocator()),
      _M_hash(__ht._M_hash),
      _M_equals(__ht._M_equals),
      _M_get_key(__ht._M_get_key),
      _M_buckets(__ht.get_allocator()),
      _M_num_elements(0)
  {
    _M_copy_from(__ht);
  }

  hashtable& operator= (const hashtable& __ht)
  {
    if (&__ht != this) {
      clear();
      _M_hash = __ht._M_hash;
      _M_equals = __ht._M_equals;
      _M_get_key = __ht._M_get_key;
      _M_copy_from(__ht);
    }
    return *this;
  }

  ~hashtable() { clear(); }

  size_type size() const { return _M_num_elements; }
  size_type max_size() const { return size_type(-1); }
  bool empty() const { return size() == 0; }

  void swap(hashtable& __ht)
  {
    std::swap(_M_hash, __ht._M_hash);
    std::swap(_M_equals, __ht._M_equals);
    std::swap(_M_get_key, __ht._M_get_key);
    _M_buckets.swap(__ht._M_buckets);
    std::swap(_M_num_elements, __ht._M_num_elements);
  }

  iterator begin()
  {
    if (false) { } else for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
      if (_M_buckets[__n])
        return iterator(_M_buckets[__n], this);
    return end();
  }

  iterator end() { return iterator(0, this); }

  const_iterator begin() const
  {
    if (false) { } else for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
      if (_M_buckets[__n])
        return const_iterator(_M_buckets[__n], this);
    return end();
  }

  const_iterator end() const { return const_iterator(0, this); }

  template <class _Vl, class _Ky, class _HF, class _Ex, class _Eq, class _Al>
  friend bool operator== (const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&,
                          const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&);
public:

  size_type bucket_count() const { return _M_buckets.size(); }

  size_type max_bucket_count() const
    { return __stl_prime_list[(int)__stl_num_primes - 1]; }

  size_type elems_in_bucket(size_type __bucket) const
  {
    size_type __result = 0;
    if (false) { } else for (_Node* __cur = _M_buckets[__bucket]; __cur; __cur = __cur->_M_next)
      __result += 1;
    return __result;
  }

  pair<iterator, bool> insert_unique(const value_type& __obj)
  {
    resize(_M_num_elements + 1);
    return insert_unique_noresize(__obj);
  }

  iterator insert_equal(const value_type& __obj)
  {
    resize(_M_num_elements + 1);
    return insert_equal_noresize(__obj);
  }

  pair<iterator, bool> insert_unique_noresize(const value_type& __obj);
  iterator insert_equal_noresize(const value_type& __obj);

  template <class _InputIterator>
  void insert_unique(_InputIterator __f, _InputIterator __l)
  {
    insert_unique(__f, __l, __iterator_category(__f));
  }

  template <class _InputIterator>
  void insert_equal(_InputIterator __f, _InputIterator __l)
  {
    insert_equal(__f, __l, __iterator_category(__f));
  }

  template <class _InputIterator>
  void insert_unique(_InputIterator __f, _InputIterator __l,
                     input_iterator_tag)
  {
    if (false) { } else for ( ; __f != __l; ++__f)
      insert_unique(*__f);
  }

  template <class _InputIterator>
  void insert_equal(_InputIterator __f, _InputIterator __l,
                    input_iterator_tag)
  {
    if (false) { } else for ( ; __f != __l; ++__f)
      insert_equal(*__f);
  }

  template <class _ForwardIterator>
  void insert_unique(_ForwardIterator __f, _ForwardIterator __l,
                     forward_iterator_tag)
  {
    size_type __n = distance(__f, __l);
    resize(_M_num_elements + __n);
    if (false) { } else for ( ; __n > 0; --__n, ++__f)
      insert_unique_noresize(*__f);
  }

  template <class _ForwardIterator>
  void insert_equal(_ForwardIterator __f, _ForwardIterator __l,
                    forward_iterator_tag)
  {
    size_type __n = distance(__f, __l);
    resize(_M_num_elements + __n);
    if (false) { } else for ( ; __n > 0; --__n, ++__f)
      insert_equal_noresize(*__f);
  }

  reference find_or_insert(const value_type& __obj);

  iterator find(const key_type& __key)
  {
    size_type __n = _M_bkt_num_key(__key);
    _Node* __first;
    if (false) { } else for ( __first = _M_buckets[__n];
          __first && !_M_equals(_M_get_key(__first->_M_val), __key);
          __first = __first->_M_next)
      {}
    return iterator(__first, this);
  }

  const_iterator find(const key_type& __key) const
  {
    size_type __n = _M_bkt_num_key(__key);
    const _Node* __first;
    if (false) { } else for ( __first = _M_buckets[__n];
          __first && !_M_equals(_M_get_key(__first->_M_val), __key);
          __first = __first->_M_next)
      {}
    return const_iterator(__first, this);
  }

  size_type count(const key_type& __key) const
  {
    const size_type __n = _M_bkt_num_key(__key);
    size_type __result = 0;

    if (false) { } else for (const _Node* __cur = _M_buckets[__n]; __cur; __cur = __cur->_M_next)
      if (_M_equals(_M_get_key(__cur->_M_val), __key))
        ++__result;
    return __result;
  }

  pair<iterator, iterator>
  equal_range(const key_type& __key);

  pair<const_iterator, const_iterator>
  equal_range(const key_type& __key) const;

  size_type erase(const key_type& __key);
  void erase(const iterator& __it);
  void erase(iterator __first, iterator __last);

  void erase(const const_iterator& __it);
  void erase(const_iterator __first, const_iterator __last);

  void resize(size_type __num_elements_hint);
  void clear();

private:
  size_type _M_next_size(size_type __n) const
    { return __stl_next_prime(__n); }

  void _M_initialize_buckets(size_type __n)
  {
    const size_type __n_buckets = _M_next_size(__n);
    _M_buckets.reserve(__n_buckets);
    _M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0);
    _M_num_elements = 0;
  }

  size_type _M_bkt_num_key(const key_type& __key) const
  {
    return _M_bkt_num_key(__key, _M_buckets.size());
  }

  size_type _M_bkt_num(const value_type& __obj) const
  {
    return _M_bkt_num_key(_M_get_key(__obj));
  }

  size_type _M_bkt_num_key(const key_type& __key, size_t __n) const
  {
    return _M_hash(__key) % __n;
  }

  size_type _M_bkt_num(const value_type& __obj, size_t __n) const
  {
    return _M_bkt_num_key(_M_get_key(__obj), __n);
  }

  _Node* _M_new_node(const value_type& __obj)
  {
    _Node* __n = _M_get_node();
    __n->_M_next = 0;
    try {
      _Construct(&__n->_M_val, __obj);
      return __n;
    }
    catch(...)
      {
        _M_put_node(__n);
        throw;
      }
  }

  void _M_delete_node(_Node* __n)
  {
    _Destroy(&__n->_M_val);
    _M_put_node(__n);
  }

  void _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last);
  void _M_erase_bucket(const size_type __n, _Node* __last);

  void _M_copy_from(const hashtable& __ht);

};

template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
          class _All>
_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&
_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++()
{
  const _Node* __old = _M_cur;
  _M_cur = _M_cur->_M_next;
  if (!_M_cur) {
    size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
    while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
      _M_cur = _M_ht->_M_buckets[__bucket];
  }
  return *this;
}

template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
          class _All>
inline _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>
_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int)
{
  iterator __tmp = *this;
  ++*this;
  return __tmp;
}

template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
          class _All>
_Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&
_Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++()
{
  const _Node* __old = _M_cur;
  _M_cur = _M_cur->_M_next;
  if (!_M_cur) {
    size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
    while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
      _M_cur = _M_ht->_M_buckets[__bucket];
  }
  return *this;
}

template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
          class _All>
inline _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>
_Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int)
{
  const_iterator __tmp = *this;
  ++*this;
  return __tmp;
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
bool operator==(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1,
                const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht2)
{
  typedef typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::_Node _Node;
  if (__ht1._M_buckets.size() != __ht2._M_buckets.size())
    return false;
  if (false) { } else for (size_t __n = 0; __n < __ht1._M_buckets.size(); ++__n) {
    _Node* __cur1 = __ht1._M_buckets[__n];
    _Node* __cur2 = __ht2._M_buckets[__n];

    if (false) { } else for ( ; __cur1 && __cur2;
          __cur1 = __cur1->_M_next, __cur2 = __cur2->_M_next)
      {}
    if (__cur1 || __cur2)
      return false;

    if (false) { } else for (__cur1 = __ht1._M_buckets[__n] ; __cur1; __cur1 = __cur1->_M_next)
    {
      bool _found__cur1 = false;
      if (false) { } else for (_Node* __cur2 = __ht2._M_buckets[__n];
           __cur2; __cur2 = __cur2->_M_next)
      {
        if (__cur1->_M_val == __cur2->_M_val)
        {
          _found__cur1 = true;
          break;
        }
      }
      if (!_found__cur1)
        return false;
    }
  }
  return true;
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
inline bool operator!=(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1,
                       const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht2) {
  return !(__ht1 == __ht2);
}

template <class _Val, class _Key, class _HF, class _Extract, class _EqKey,
          class _All>
inline void swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1,
                 hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht2) {
  __ht1.swap(__ht2);
}


template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, bool>
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::insert_unique_noresize(const value_type& __obj)
{
  const size_type __n = _M_bkt_num(__obj);
  _Node* __first = _M_buckets[__n];

  if (false) { } else for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
    if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
      return pair<iterator, bool>(iterator(__cur, this), false);

  _Node* __tmp = _M_new_node(__obj);
  __tmp->_M_next = __first;
  _M_buckets[__n] = __tmp;
  ++_M_num_elements;
  return pair<iterator, bool>(iterator(__tmp, this), true);
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::insert_equal_noresize(const value_type& __obj)
{
  const size_type __n = _M_bkt_num(__obj);
  _Node* __first = _M_buckets[__n];

  if (false) { } else for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
    if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) {
      _Node* __tmp = _M_new_node(__obj);
      __tmp->_M_next = __cur->_M_next;
      __cur->_M_next = __tmp;
      ++_M_num_elements;
      return iterator(__tmp, this);
    }

  _Node* __tmp = _M_new_node(__obj);
  __tmp->_M_next = __first;
  _M_buckets[__n] = __tmp;
  ++_M_num_elements;
  return iterator(__tmp, this);
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::reference
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::find_or_insert(const value_type& __obj)
{
  resize(_M_num_elements + 1);

  size_type __n = _M_bkt_num(__obj);
  _Node* __first = _M_buckets[__n];

  if (false) { } else for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
    if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
      return __cur->_M_val;

  _Node* __tmp = _M_new_node(__obj);
  __tmp->_M_next = __first;
  _M_buckets[__n] = __tmp;
  ++_M_num_elements;
  return __tmp->_M_val;
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator,
     typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator>
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key)
{
  typedef pair<iterator, iterator> _Pii;
  const size_type __n = _M_bkt_num_key(__key);

  if (false) { } else for (_Node* __first = _M_buckets[__n]; __first; __first = __first->_M_next)
    if (_M_equals(_M_get_key(__first->_M_val), __key)) {
      if (false) { } else for (_Node* __cur = __first->_M_next; __cur; __cur = __cur->_M_next)
        if (!_M_equals(_M_get_key(__cur->_M_val), __key))
          return _Pii(iterator(__first, this), iterator(__cur, this));
      if (false) { } else for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
        if (_M_buckets[__m])
          return _Pii(iterator(__first, this),
                     iterator(_M_buckets[__m], this));
      return _Pii(iterator(__first, this), end());
    }
  return _Pii(end(), end());
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator,
     typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator>
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::equal_range(const key_type& __key) const
{
  typedef pair<const_iterator, const_iterator> _Pii;
  const size_type __n = _M_bkt_num_key(__key);

  if (false) { } else for (const _Node* __first = _M_buckets[__n] ;
       __first;
       __first = __first->_M_next) {
    if (_M_equals(_M_get_key(__first->_M_val), __key)) {
      if (false) { } else for (const _Node* __cur = __first->_M_next;
           __cur;
           __cur = __cur->_M_next)
        if (!_M_equals(_M_get_key(__cur->_M_val), __key))
          return _Pii(const_iterator(__first, this),
                      const_iterator(__cur, this));
      if (false) { } else for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m)
        if (_M_buckets[__m])
          return _Pii(const_iterator(__first, this),
                      const_iterator(_M_buckets[__m], this));
      return _Pii(const_iterator(__first, this), end());
    }
  }
  return _Pii(end(), end());
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::size_type
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const key_type& __key)
{
  const size_type __n = _M_bkt_num_key(__key);
  _Node* __first = _M_buckets[__n];
  size_type __erased = 0;

  if (__first) {
    _Node* __cur = __first;
    _Node* __next = __cur->_M_next;
    while (__next) {
      if (_M_equals(_M_get_key(__next->_M_val), __key)) {
        __cur->_M_next = __next->_M_next;
        _M_delete_node(__next);
        __next = __cur->_M_next;
        ++__erased;
        --_M_num_elements;
      }
      else {
        __cur = __next;
        __next = __cur->_M_next;
      }
    }
    if (_M_equals(_M_get_key(__first->_M_val), __key)) {
      _M_buckets[__n] = __first->_M_next;
      _M_delete_node(__first);
      ++__erased;
      --_M_num_elements;
    }
  }
  return __erased;
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const iterator& __it)
{
  _Node* __p = __it._M_cur;
  if (__p) {
    const size_type __n = _M_bkt_num(__p->_M_val);
    _Node* __cur = _M_buckets[__n];

    if (__cur == __p) {
      _M_buckets[__n] = __cur->_M_next;
      _M_delete_node(__cur);
      --_M_num_elements;
    }
    else {
      _Node* __next = __cur->_M_next;
      while (__next) {
        if (__next == __p) {
          __cur->_M_next = __next->_M_next;
          _M_delete_node(__next);
          --_M_num_elements;
          break;
        }
        else {
          __cur = __next;
          __next = __cur->_M_next;
        }
      }
    }
  }
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::erase(iterator __first, iterator __last)
{
  size_type __f_bucket = __first._M_cur ?
    _M_bkt_num(__first._M_cur->_M_val) : _M_buckets.size();
  size_type __l_bucket = __last._M_cur ?
    _M_bkt_num(__last._M_cur->_M_val) : _M_buckets.size();

  if (__first._M_cur == __last._M_cur)
    return;
  else if (__f_bucket == __l_bucket)
    _M_erase_bucket(__f_bucket, __first._M_cur, __last._M_cur);
  else {
    _M_erase_bucket(__f_bucket, __first._M_cur, 0);
    if (false) { } else for (size_type __n = __f_bucket + 1; __n < __l_bucket; ++__n)
      _M_erase_bucket(__n, 0);
    if (__l_bucket != _M_buckets.size())
      _M_erase_bucket(__l_bucket, __last._M_cur);
  }
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
inline void
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const_iterator __first,
                                             const_iterator __last)
{
  erase(iterator(const_cast<_Node*>(__first._M_cur),
                 const_cast<hashtable*>(__first._M_ht)),
        iterator(const_cast<_Node*>(__last._M_cur),
                 const_cast<hashtable*>(__last._M_ht)));
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
inline void
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const const_iterator& __it)
{
  erase(iterator(const_cast<_Node*>(__it._M_cur),
                 const_cast<hashtable*>(__it._M_ht)));
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::resize(size_type __num_elements_hint)
{
  const size_type __old_n = _M_buckets.size();
  if (__num_elements_hint > __old_n) {
    const size_type __n = _M_next_size(__num_elements_hint);
    if (__n > __old_n) {
      vector<_Node*, _All> __tmp(__n, (_Node*)(0),
                                 _M_buckets.get_allocator());
      try {
        if (false) { } else for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) {
          _Node* __first = _M_buckets[__bucket];
          while (__first) {
            size_type __new_bucket = _M_bkt_num(__first->_M_val, __n);
            _M_buckets[__bucket] = __first->_M_next;
            __first->_M_next = __tmp[__new_bucket];
            __tmp[__new_bucket] = __first;
            __first = _M_buckets[__bucket];
          }
        }
        _M_buckets.swap(__tmp);
      }
      catch(...) {
        if (false) { } else for (size_type __bucket = 0; __bucket < __tmp.size(); ++__bucket) {
          while (__tmp[__bucket]) {
            _Node* __next = __tmp[__bucket]->_M_next;
            _M_delete_node(__tmp[__bucket]);
            __tmp[__bucket] = __next;
          }
        }
        throw;
      }
    }
  }
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::_M_erase_bucket(const size_type __n, _Node* __first, _Node* __last)
{
  _Node* __cur = _M_buckets[__n];
  if (__cur == __first)
    _M_erase_bucket(__n, __last);
  else {
    _Node* __next;
    if (false) { } else for (__next = __cur->_M_next;
         __next != __first;
         __cur = __next, __next = __cur->_M_next)
      ;
    while (__next != __last) {
      __cur->_M_next = __next->_M_next;
      _M_delete_node(__next);
      __next = __cur->_M_next;
      --_M_num_elements;
    }
  }
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::_M_erase_bucket(const size_type __n, _Node* __last)
{
  _Node* __cur = _M_buckets[__n];
  while (__cur != __last) {
    _Node* __next = __cur->_M_next;
    _M_delete_node(__cur);
    __cur = __next;
    _M_buckets[__n] = __cur;
    --_M_num_elements;
  }
}

template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::clear()
{
  if (false) { } else for (size_type __i = 0; __i < _M_buckets.size(); ++__i) {
    _Node* __cur = _M_buckets[__i];
    while (__cur != 0) {
      _Node* __next = __cur->_M_next;
      _M_delete_node(__cur);
      __cur = __next;
    }
    _M_buckets[__i] = 0;
  }
  _M_num_elements = 0;
}


template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
  ::_M_copy_from(const hashtable& __ht)
{
  _M_buckets.clear();
  _M_buckets.reserve(__ht._M_buckets.size());
  _M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0);
  try {
    if (false) { } else for (size_type __i = 0; __i < __ht._M_buckets.size(); ++__i) {
      const _Node* __cur = __ht._M_buckets[__i];
      if (__cur) {
        _Node* __local_copy = _M_new_node(__cur->_M_val);
        _M_buckets[__i] = __local_copy;

        if (false) { } else for (_Node* __next = __cur->_M_next;
             __next;
             __cur = __next, __next = __cur->_M_next) {
          __local_copy->_M_next = _M_new_node(__next->_M_val);
          __local_copy = __local_copy->_M_next;
        }
      }
    }
    _M_num_elements = __ht._M_num_elements;
  }
  catch(...)
    {
      clear();
      throw;
    }
}

}
# 66 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/ext/hash_map" 2 3


namespace __gnu_cxx
{
using std::equal_to;
using std::allocator;
using std::pair;
using std::_Select1st;



template <class _Key, class _Tp,
          class _HashFcn = hash<_Key>,
          class _EqualKey = equal_to<_Key>,
          class _Alloc = allocator<_Tp> >
class hash_map;

template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
inline bool operator==(const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&,
                       const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&);





template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
          class _Alloc>
class hash_map
{
private:
  typedef hashtable<pair<const _Key,_Tp>,_Key,_HashFcn,
                    _Select1st<pair<const _Key,_Tp> >,_EqualKey,_Alloc> _Ht;
  _Ht _M_ht;

public:
  typedef typename _Ht::key_type key_type;
  typedef _Tp data_type;
  typedef _Tp mapped_type;
  typedef typename _Ht::value_type value_type;
  typedef typename _Ht::hasher hasher;
  typedef typename _Ht::key_equal key_equal;

  typedef typename _Ht::size_type size_type;
  typedef typename _Ht::difference_type difference_type;
  typedef typename _Ht::pointer pointer;
  typedef typename _Ht::const_pointer const_pointer;
  typedef typename _Ht::reference reference;
  typedef typename _Ht::const_reference const_reference;

  typedef typename _Ht::iterator iterator;
  typedef typename _Ht::const_iterator const_iterator;

  typedef typename _Ht::allocator_type allocator_type;

  hasher hash_funct() const { return _M_ht.hash_funct(); }
  key_equal key_eq() const { return _M_ht.key_eq(); }
  allocator_type get_allocator() const { return _M_ht.get_allocator(); }

public:
  hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  explicit hash_map(size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  hash_map(size_type __n, const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
           const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a) {}

  template <class _InputIterator>
  hash_map(_InputIterator __f, _InputIterator __l)
    : _M_ht(100, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
  template <class _InputIterator>
  hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
  template <class _InputIterator>
  hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
           const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type())
    { _M_ht.insert_unique(__f, __l); }
  template <class _InputIterator>
  hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
           const hasher& __hf, const key_equal& __eql,
           const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a)
    { _M_ht.insert_unique(__f, __l); }

public:
  size_type size() const { return _M_ht.size(); }
  size_type max_size() const { return _M_ht.max_size(); }
  bool empty() const { return _M_ht.empty(); }
  void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); }

  template <class _K1, class _T1, class _HF, class _EqK, class _Al>
  friend bool operator== (const hash_map<_K1, _T1, _HF, _EqK, _Al>&,
                          const hash_map<_K1, _T1, _HF, _EqK, _Al>&);

  iterator begin() { return _M_ht.begin(); }
  iterator end() { return _M_ht.end(); }
  const_iterator begin() const { return _M_ht.begin(); }
  const_iterator end() const { return _M_ht.end(); }

public:
  pair<iterator,bool> insert(const value_type& __obj)
    { return _M_ht.insert_unique(__obj); }
  template <class _InputIterator>
  void insert(_InputIterator __f, _InputIterator __l)
    { _M_ht.insert_unique(__f,__l); }
  pair<iterator,bool> insert_noresize(const value_type& __obj)
    { return _M_ht.insert_unique_noresize(__obj); }

  iterator find(const key_type& __key) { return _M_ht.find(__key); }
  const_iterator find(const key_type& __key) const
    { return _M_ht.find(__key); }

  _Tp& operator[](const key_type& __key) {
    return _M_ht.find_or_insert(value_type(__key, _Tp())).second;
  }

  size_type count(const key_type& __key) const { return _M_ht.count(__key); }

  pair<iterator, iterator> equal_range(const key_type& __key)
    { return _M_ht.equal_range(__key); }
  pair<const_iterator, const_iterator>
  equal_range(const key_type& __key) const
    { return _M_ht.equal_range(__key); }

  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  void erase(iterator __it) { _M_ht.erase(__it); }
  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  void clear() { _M_ht.clear(); }

  void resize(size_type __hint) { _M_ht.resize(__hint); }
  size_type bucket_count() const { return _M_ht.bucket_count(); }
  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  size_type elems_in_bucket(size_type __n) const
    { return _M_ht.elems_in_bucket(__n); }
};

template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
inline bool
operator==(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
           const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
{
  return __hm1._M_ht == __hm2._M_ht;
}

template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
inline bool
operator!=(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
           const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) {
  return !(__hm1 == __hm2);
}

template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
inline void
swap(hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
     hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
{
  __hm1.swap(__hm2);
}



template <class _Key, class _Tp,
          class _HashFcn = hash<_Key>,
          class _EqualKey = equal_to<_Key>,
          class _Alloc = allocator<_Tp> >
class hash_multimap;

template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
inline bool
operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
           const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2);






template <class _Key, class _Tp, class _HashFcn, class _EqualKey, class _Alloc>
class hash_multimap
{

 
 
  ;
  ;

private:
  typedef hashtable<pair<const _Key, _Tp>, _Key, _HashFcn,
                    _Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc>
          _Ht;
  _Ht _M_ht;

public:
  typedef typename _Ht::key_type key_type;
  typedef _Tp data_type;
  typedef _Tp mapped_type;
  typedef typename _Ht::value_type value_type;
  typedef typename _Ht::hasher hasher;
  typedef typename _Ht::key_equal key_equal;

  typedef typename _Ht::size_type size_type;
  typedef typename _Ht::difference_type difference_type;
  typedef typename _Ht::pointer pointer;
  typedef typename _Ht::const_pointer const_pointer;
  typedef typename _Ht::reference reference;
  typedef typename _Ht::const_reference const_reference;

  typedef typename _Ht::iterator iterator;
  typedef typename _Ht::const_iterator const_iterator;

  typedef typename _Ht::allocator_type allocator_type;

  hasher hash_funct() const { return _M_ht.hash_funct(); }
  key_equal key_eq() const { return _M_ht.key_eq(); }
  allocator_type get_allocator() const { return _M_ht.get_allocator(); }

public:
  hash_multimap() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  explicit hash_multimap(size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  hash_multimap(size_type __n, const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
                const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a) {}

  template <class _InputIterator>
  hash_multimap(_InputIterator __f, _InputIterator __l)
    : _M_ht(100, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_equal(__f, __l); }
  template <class _InputIterator>
  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
    : _M_ht(__n, hasher(), key_equal(), allocator_type())
    { _M_ht.insert_equal(__f, __l); }
  template <class _InputIterator>
  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
                const hasher& __hf)
    : _M_ht(__n, __hf, key_equal(), allocator_type())
    { _M_ht.insert_equal(__f, __l); }
  template <class _InputIterator>
  hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
                const hasher& __hf, const key_equal& __eql,
                const allocator_type& __a = allocator_type())
    : _M_ht(__n, __hf, __eql, __a)
    { _M_ht.insert_equal(__f, __l); }

public:
  size_type size() const { return _M_ht.size(); }
  size_type max_size() const { return _M_ht.max_size(); }
  bool empty() const { return _M_ht.empty(); }
  void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); }

  template <class _K1, class _T1, class _HF, class _EqK, class _Al>
  friend bool operator== (const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&,
                          const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&);

  iterator begin() { return _M_ht.begin(); }
  iterator end() { return _M_ht.end(); }
  const_iterator begin() const { return _M_ht.begin(); }
  const_iterator end() const { return _M_ht.end(); }

public:
  iterator insert(const value_type& __obj)
    { return _M_ht.insert_equal(__obj); }
  template <class _InputIterator>
  void insert(_InputIterator __f, _InputIterator __l)
    { _M_ht.insert_equal(__f,__l); }
  iterator insert_noresize(const value_type& __obj)
    { return _M_ht.insert_equal_noresize(__obj); }

  iterator find(const key_type& __key) { return _M_ht.find(__key); }
  const_iterator find(const key_type& __key) const
    { return _M_ht.find(__key); }

  size_type count(const key_type& __key) const { return _M_ht.count(__key); }

  pair<iterator, iterator> equal_range(const key_type& __key)
    { return _M_ht.equal_range(__key); }
  pair<const_iterator, const_iterator>
  equal_range(const key_type& __key) const
    { return _M_ht.equal_range(__key); }

  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  void erase(iterator __it) { _M_ht.erase(__it); }
  void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  void clear() { _M_ht.clear(); }

public:
  void resize(size_type __hint) { _M_ht.resize(__hint); }
  size_type bucket_count() const { return _M_ht.bucket_count(); }
  size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  size_type elems_in_bucket(size_type __n) const
    { return _M_ht.elems_in_bucket(__n); }
};

template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
inline bool
operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
           const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2)
{
  return __hm1._M_ht == __hm2._M_ht;
}

template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
inline bool
operator!=(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
           const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2) {
  return !(__hm1 == __hm2);
}

template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
inline void
swap(hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
     hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
{
  __hm1.swap(__hm2);
}

}

namespace std
{



template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
class insert_iterator<__gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
protected:
  typedef __gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
  _Container* container;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  insert_iterator(_Container& __x) : container(&__x) {}
  insert_iterator(_Container& __x, typename _Container::iterator)
    : container(&__x) {}
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    container->insert(__value);
    return *this;
  }
  insert_iterator<_Container>& operator*() { return *this; }
  insert_iterator<_Container>& operator++() { return *this; }
  insert_iterator<_Container>& operator++(int) { return *this; }
};

template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
class insert_iterator<__gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
protected:
  typedef __gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
  _Container* container;
  typename _Container::iterator iter;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  insert_iterator(_Container& __x) : container(&__x) {}
  insert_iterator(_Container& __x, typename _Container::iterator)
    : container(&__x) {}
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    container->insert(__value);
    return *this;
  }
  insert_iterator<_Container>& operator*() { return *this; }
  insert_iterator<_Container>& operator++() { return *this; }
  insert_iterator<_Container>& operator++(int) { return *this; }
};

}
# 63 "/tmp/installed/include/InsightToolkit/Common/itk_hash_map.h" 2

namespace itk
{
  using __gnu_cxx::hash;
  using __gnu_cxx::hash_map;
  using __gnu_cxx::hash_multimap;
}
# 28 "/tmp/installed/include/InsightToolkit/Common/itkEquivalencyTable.h" 2

namespace itk
{
# 47 "/tmp/installed/include/InsightToolkit/Common/itkEquivalencyTable.h"
class EquivalencyTable : public DataObject
{
public:

  typedef EquivalencyTable Self;
  typedef DataObject Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;
  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };
  virtual const char *GetNameOfClass() const {return "EquivalencyTable";};


  typedef itk::hash_map<unsigned long, unsigned long,
                        itk::hash<unsigned long> > HashTableType;
  typedef HashTableType::iterator Iterator;
  typedef HashTableType::const_iterator ConstIterator;
  typedef HashTableType::value_type ValueType;




  void Flatten();







  bool Add(unsigned long a, unsigned long b);




  unsigned long Lookup(const unsigned long a) const
  {
    ConstIterator result = m_HashMap.find(a);
    if ( result == m_HashMap.end() ) return a;
    else return (*result).second;
  }





  unsigned long RecursiveLookup(const unsigned a) const;



  bool IsEntry(const unsigned long a) const
  {
    if ( m_HashMap.find(a) == m_HashMap.end() ) return false;
    else return true;
  }


  void Erase(const unsigned long a)
  { m_HashMap.erase(a); }


  void Clear()
  { m_HashMap.clear(); }


  bool Empty() const
  { return m_HashMap.empty(); }


  HashTableType::size_type Size() const
  { return m_HashMap.size(); }



  Iterator Begin() { return m_HashMap.begin(); }



  Iterator End() { return m_HashMap.end(); }



protected:
  EquivalencyTable() {}
  virtual ~EquivalencyTable() {}
  EquivalencyTable(const Self&);
  void operator=(const Self&);
  void PrintSelf(std::ostream& os, Indent indent) const;

  HashTableType m_HashMap;
};

}
# 26 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.txx" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.h"
#define __itkConstShapedNeighborhoodIterator_h 



# 1 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.h"
#define __itkNeighborhoodIterator_h 




# 1 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h"
#define __itkConstNeighborhoodIterator_h 
# 29 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h"
# 1 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.h"
#define __itkNeighborhood_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodAllocator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodAllocator.h"
#define __itkNeighborhoodAllocator_h 


namespace itk {
# 34 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodAllocator.h"
template <class TPixel>
class NeighborhoodAllocator
{
public:

  typedef NeighborhoodAllocator Self;





  typedef TPixel * iterator;
  typedef const TPixel * const_iterator;


  NeighborhoodAllocator() : m_ElementCount(0), m_Data(0) {}


  ~NeighborhoodAllocator()
    { this->Deallocate(); }


  void Allocate(unsigned int n)
  {
    m_Data = new TPixel[n];
    m_ElementCount = n;
  }


  void Deallocate()
  {
    if (m_Data) delete[] m_Data;
    m_ElementCount = 0;
  }


  NeighborhoodAllocator(const Self& other) : m_ElementCount(0), m_Data(0)
  {
    this->set_size(other.m_ElementCount);
    if (false) { } else for (unsigned int i = 0; i < other.m_ElementCount; ++i)
      this->operator[](i) = other[i];
    m_ElementCount = other.m_ElementCount;
  }


  const Self& operator=(const Self& other)
  {
    this->set_size(other.m_ElementCount);
    if (false) { } else for (unsigned int i = 0; i < other.m_ElementCount; ++i)
      this->operator[](i) = other[i];
    m_ElementCount = other.m_ElementCount;
    return *this;
  }


  bool operator==(const Self& other) const
  {
    return (m_Data == other.m_Data);
  }


  bool operator!=(const Self& other) const
  {
    return (m_Data != other.m_Data);
  }


  iterator begin()
    { return m_Data; }
  const_iterator begin() const
    { return m_Data; }
  iterator end()
    { return (m_Data + m_ElementCount); }
  const_iterator end() const
    { return (m_Data + m_ElementCount); }
  unsigned int size() const
    { return m_ElementCount; }


  const TPixel & operator[](unsigned int i) const
    { return m_Data[i]; }
  TPixel &operator[](unsigned int i)
    { return m_Data[i]; }


  void set_size(unsigned int n)
    {
    if (m_Data) { Deallocate(); }
    this->Allocate(n);
    }

protected:
  unsigned int m_ElementCount;
  TPixel *m_Data;
};

template<class TPixel>
inline std::ostream& operator<<(std::ostream &o, const NeighborhoodAllocator<TPixel>
                                & a)
{
    o << "NeighborhoodAllocator { this = " << &a << ", begin = "
      << static_cast<const void *>(a.begin())
      << ", size=" << a.size()
      << " }";


    o << " } }";
  return o;
}



}
# 22 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.h" 2


# 1 "/tmp/installed/include/InsightToolkit/Common/itkSliceIterator.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkSliceIterator.h"
#define __itkSliceIterator_h 


# 1 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 1
# 22 "/tmp/installed/include/InsightToolkit/Common/itkSliceIterator.h" 2
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 1 3
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 3
#define _CPP_VALARRAY 1

       
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 3





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/numeric" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/numeric" 3
#define _CPP_NUMERIC 1

       
# 65 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/numeric" 3




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_numeric.h" 1 3
# 62 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/stl_numeric.h" 3
#define _CPP_BITS_STL_NUMERIC_H 1

namespace std
{

  template<typename _InputIterator, typename _Tp>
    _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
    {

     

      if (false) { } else for ( ; __first != __last; ++__first)
        __init = __init + *__first;
      return __init;
    }

  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
               _BinaryOperation __binary_op)
    {

     

      if (false) { } else for ( ; __first != __last; ++__first)
        __init = __binary_op(__init, *__first);
      return __init;
    }

  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
    _Tp
    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init)
    {

     
     

      if (false) { } else for ( ; __first1 != __last1; ++__first1, ++__first2)
        __init = __init + (*__first1 * *__first2);
      return __init;
    }

  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
            typename _BinaryOperation1, typename _BinaryOperation2>
    _Tp
    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init,
                  _BinaryOperation1 __binary_op1,
                  _BinaryOperation2 __binary_op2)
    {

     
     

      if (false) { } else for ( ; __first1 != __last1; ++__first1, ++__first2)
        __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
      return __init;
    }

  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    partial_sum(_InputIterator __first, _InputIterator __last,
                _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      if (__first == __last) return __result;
      *__result = *__first;
      _ValueType __value = *__first;
      while (++__first != __last) {
        __value = __value + *__first;
        *++__result = __value;
      }
      return ++__result;
    }

  template<typename _InputIterator, typename _OutputIterator, typename _BinaryOperation>
    _OutputIterator
    partial_sum(_InputIterator __first, _InputIterator __last,
                _OutputIterator __result, _BinaryOperation __binary_op)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      if (__first == __last) return __result;
      *__result = *__first;
      _ValueType __value = *__first;
      while (++__first != __last) {
        __value = __binary_op(__value, *__first);
        *++__result = __value;
      }
      return ++__result;
    }

  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    adjacent_difference(_InputIterator __first,
                        _InputIterator __last, _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      if (__first == __last) return __result;
      *__result = *__first;
      _ValueType __value = *__first;
      while (++__first != __last) {
        _ValueType __tmp = *__first;
        *++__result = __tmp - __value;
        __value = __tmp;
      }
      return ++__result;
    }

  template<typename _InputIterator, typename _OutputIterator, typename _BinaryOperation>
    _OutputIterator
    adjacent_difference(_InputIterator __first, _InputIterator __last,
                        _OutputIterator __result, _BinaryOperation __binary_op)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      if (__first == __last) return __result;
      *__result = *__first;
      _ValueType __value = *__first;
      while (++__first != __last) {
        _ValueType __tmp = *__first;
        *++__result = __binary_op(__tmp, __value);
        __value = __tmp;
      }
      return ++__result;
    }

}
# 70 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/numeric" 2 3
# 48 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3


namespace std
{
  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-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_array.h" 1 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_array.h" 3
#define _CPP_BITS_ARRAY_H 1

       
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_array.h" 3







namespace std
{





  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__>
         (__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)
       { 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_fundamental<_Tp>::_M_type>::
         _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_fundamental<_Tp>::_M_type>::
         _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)
       { 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_fundamental<_Tp>::_M_type>::
         _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_fundamental<_Tp>::_M_type)
         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_fundamental<_Tp>::_M_type)
         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_fundamental<_Tp>::_M_type)
         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)
     { if (false) { } else 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)
     { if (false) { } else 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)
       { 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_fundamental<_Tp>::_M_type>::
         _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)
     { if (false) { } else 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)
     { if (false) { } else 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)
     {
       if (false) { } else 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)
     { if (false) { } else 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)
     { if (false) { } else 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)
     {
       if (false) { } else for (size_t __k = 0; __k < __n; ++__k)
         __dst[*__j++] = __src[*__i++];
     }
# 307 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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];
       if (false) { } else 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];
       if (false) { } else 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_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
     { __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)
     { __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)
     { __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)
     { __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)
     { __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)
     { __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)
     { __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)
     { __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)
     {
       __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))
     { __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))
     { __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]; } }
# 606 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_array.h" 3
   template<typename _Tp> inline void _Array_augmented___plus (_Array<_Tp> __a, size_t __n, const _Tp& __t) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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) { if (false) { } else 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; if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else 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); if (false) { } else for (size_t __i=0; __i<__n; ++__i, ++ok, ++__p) { while (! *ok) { ++ok; ++__p; } *__p >>= __e[__i]; } }



}


#define export 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_array.tcc" 1 3
# 33 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_array.tcc" 3
#define _CPP_BITS_VALARRAY_ARRAY_TCC 1

namespace std
{

 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);
    if (false) { } else 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);
    if (false) { } else 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);
    if (false) { } else for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++__ok, ++__q) {
        while (! *__ok) {
            ++__ok;
            ++__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);
    if (false) { } else 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);
    if (false) { } else 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);
    if (false) { } else for (size_t __k=0; __k<__n; ++__k, ++__j) __a._M_data[*__j] = __e[__k];
}

 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);
    if (false) { } else 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);
    if (false) { } else 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);
    if (false) { } else for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++__ok, ++__p) {
        while (! *__ok) {
            ++__ok;
            ++__p;
        }
        new (__q) _Tp(*__p);
    }
}




}
# 624 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_array.h" 2 3
# 93 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.h" 1 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.h" 3
#define _CPP_VALARRAY_META_H 1

       
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.h" 3

namespace std
{
# 54 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.h" 3
  template<typename _Tp1, typename _Tp2> class _Constant;
# 64 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.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 _Tp 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) {}
    };




    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
    { return _M_closure[__s]; }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos,_Tp>::operator[](const gslice& __gs) const
    { return _M_closure[__gs]; }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos,_Tp>::operator[](const valarray<bool>& __m) const
    { return _M_closure[__m]; }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos,_Tp>::operator[](const valarray<size_t>& __i) const
    { return _M_closure[__i]; }

  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
    { return valarray<_Tp>(_M_closure).shift(__n); }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::cshift(int __n) const
    { return valarray<_Tp>(_M_closure).cshift(__n); }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
    { return valarray<_Tp>(_M_closure).apply(__f); }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
    { return valarray<_Tp>(_M_closure).apply(__f); }


  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,_Tp>(_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)); }
# 927 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.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 ())); }
# 995 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.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)); }
# 1034 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.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)); }
# 1135 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/valarray_meta.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

}
# 94 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3

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


      valarray<_Tp>& operator=(const valarray<_Tp>&);
      valarray<_Tp>& operator=(const _Tp&);
      valarray<_Tp>& operator=(const slice_array<_Tp>&);
      valarray<_Tp>& operator=(const gslice_array<_Tp>&);
      valarray<_Tp>& operator=(const mask_array<_Tp>&);
      valarray<_Tp>& operator=(const indirect_array<_Tp>&);

      template<class _Dom> valarray<_Tp>&
        operator= (const _Expr<_Dom,_Tp>&);



      const _Tp& operator[](size_t) const;
      _Tp& operator[](size_t);

      _Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const;
      slice_array<_Tp> operator[](slice);
      _Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const;
      gslice_array<_Tp> operator[](const gslice&);
      valarray<_Tp> operator[](const valarray<bool>&) const;
      mask_array<_Tp> operator[](const valarray<bool>&);
      _Expr<_IClos<_ValArray, _Tp>, _Tp>
        operator[](const valarray<size_t>&) const;
      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;




      valarray<_Tp> shift (int) const;
      valarray<_Tp> cshift(int) const;
      _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const;
      _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const;
      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-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/slice_array.h" 1 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/slice_array.h" 3
#define _CPP_BITS_SLICE_ARRAY_H 1

       
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/slice_array.h" 3

namespace std
{
  class slice
  {
  public:
    slice();
    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() {}

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

  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)
    {
      __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
    { __valarray_fill(_M_array, _M_sz, _M_stride, __t); }

  template<typename _Tp>
    inline void
    slice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
    { __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
    { __valarray_copy(__e, _M_sz, _M_array, _M_stride); }


#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); }
# 199 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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

}
# 234 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/gslice.h" 1 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/gslice.h" 3
#define _CPP_BITS_GSLICE_H 1

       
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/gslice.h" 3

namespace std {

    class gslice
    {
    public:
        gslice ();
        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(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(0) {}

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


}
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/gslice_array.h" 1 3
# 38 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/gslice_array.h" 3
#define _CPP_BITS_GSLICE_ARRAY 1

       
# 41 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/gslice_array.h" 3

namespace std {

  template<typename _Tp>
    class gslice_array
    {
    public:
      typedef _Tp value_type;

      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(const gslice_array&);


      gslice_array();
      gslice_array& operator= (const 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 void
    gslice_array<_Tp>::operator=(const _Tp& __t) const
    {
      __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
    {
      __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
      {
        __valarray_copy (__e, _M_index.size(), _M_array,
                         _Array<size_t>(_M_index));
      }


#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()); }
# 159 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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

}
# 236 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/mask_array.h" 1 3
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/mask_array.h" 3
#define _CPP_BITS_MASK_ARRAY_H 1

       
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/mask_array.h" 3

namespace std {

  template <class _Tp>
    class mask_array
    {
    public:
      typedef _Tp value_type;

      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 (const mask_array&);


      mask_array();
      mask_array& operator=(const 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 void
    mask_array<_Tp>::operator=(const _Tp& __t) const
    { __valarray_fill(_M_array, _M_sz, _M_mask, __t); }

  template<typename _Tp>
    inline void
    mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const
    { __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
      { __valarray_copy(__e, __e.size(), _M_array, _M_mask); }


#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()); }
# 148 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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

}
# 237 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/indirect_array.h" 1 3
# 39 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/indirect_array.h" 3
#define _CPP_BITS_INDIRECT_ARRAY_H 1

       
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/bits/indirect_array.h" 3

namespace std
{
  template <class _Tp>
     class indirect_array
     {
     public:
       typedef _Tp value_type;


       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(const indirect_array&);
       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)
     {
       __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
     { __valarray_fill(_M_array, _M_index, _M_sz, __t); }

  template<typename _Tp>
     inline void
     indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
     { __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
       { __valarray_copy(__e, _M_sz, _M_array, _M_index); }


#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); }
# 159 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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

}
# 238 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 2 3

namespace std
{
  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))
    { __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))
    { __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))
    { __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))
    { __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))
    {
      __valarray_copy
        (__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))
    {
      __valarray_copy
        (__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))
    {
      __valarray_copy
        (__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))
    {
      __valarray_copy
        (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
    }

  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))
    { __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); }

  template<typename _Tp>
    inline
    valarray<_Tp>::~valarray()
    {
      __valarray_destroy_elements(_M_data, _M_data + _M_size);
      __valarray_release_memory(_M_data);
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const valarray<_Tp>& __v)
    {
      __valarray_copy(__v._M_data, _M_size, _M_data);
      return *this;
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const _Tp& __t)
    {
      __valarray_fill(_M_data, _M_size, __t);
      return *this;
    }

  template<typename _Tp>
    inline valarray<_Tp>&
    valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
    {
      __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)
    {
      __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)
    {
      __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)
    {
      __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)
    {
      __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();
      if (false) { } else 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();
      if (false) { } else 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 __valarray_sum(_M_data, _M_data + _M_size);
    }
# 471 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/valarray" 3
  template <class _Tp>
     inline valarray<_Tp>
     valarray<_Tp>::shift(int __n) const
     {
       _Tp* const __a = static_cast<_Tp*>
         (__builtin_alloca(sizeof(_Tp) * _M_size));
       if (__n == 0)
         __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
       else if (__n > 0)
         {
           if (size_t(__n) > _M_size)
             __valarray_default_construct(__a, __a + __n);
           else
             {
               __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
               __valarray_default_construct(__a+_M_size-__n, __a + _M_size);
             }
         }
       else
         {
           __valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n);
           __valarray_default_construct(__a, __a - __n);
         }
       return valarray<_Tp> (__a, _M_size);
     }

  template <class _Tp>
     inline valarray<_Tp>
     valarray<_Tp>::cshift (int __n) const
     {
       _Tp* const __a = static_cast<_Tp*>
         (__builtin_alloca (sizeof(_Tp) * _M_size));
       if (__n == 0)
         __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
       else if (__n > 0)
         {
           __valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
           __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
         }
       else
         {
           __valarray_copy_construct
             (_M_data + _M_size+__n, _M_data + _M_size, __a);
           __valarray_copy_construct
             (_M_data, _M_data + _M_size+__n, __a - __n);
         }
       return valarray<_Tp>(__a, _M_size);
     }

  template <class _Tp>
    inline void
    valarray<_Tp>::resize (size_t __n, _Tp __c)
    {



      __valarray_destroy_elements(_M_data, _M_data + _M_size);
      if (_M_size != __n)
        {
          __valarray_release_memory(_M_data);
          _M_size = __n;
          _M_data = __valarray_get_storage<_Tp>(__n);
        }
      __valarray_fill_construct(_M_data, _M_data + __n, __c);
    }

  template<typename _Tp>
    inline _Tp
    valarray<_Tp>::min() const
    {
      return *min_element (_M_data, _M_data+_M_size);
    }

  template<typename _Tp>
    inline _Tp
    valarray<_Tp>::max() const
    {
      return *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)); }
# 577 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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) { _Array_augmented_ ##_Name(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; }
# 602 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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; }
# 624 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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) { 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, _Tp>(_Closure(__t, __v)); }
# 669 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.5/include/g++-v3/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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_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, _Tp>(_Closure(__t, __v)); }

}
# 23 "/tmp/installed/include/InsightToolkit/Common/itkSliceIterator.h" 2
namespace itk {
# 44 "/tmp/installed/include/InsightToolkit/Common/itkSliceIterator.h"
template<class TPixel, class TContainer>
class SliceIterator
{
public:

  SliceIterator(TContainer *n, std::slice s)
    : m_ContainerPointer(n), m_Pos(0), m_Slice(s) {}


  SliceIterator Begin()
    {
      SliceIterator ans = *this;
      ans.m_Pos = 0;
      return ans;
    }


  SliceIterator End()
    {
      SliceIterator ans = *this;
      ans.m_Pos = static_cast<unsigned long>(m_Slice.size());
      return ans;
    }


  SliceIterator operator++()
    {
      m_Pos++;
      return *this;
    }


  SliceIterator operator++(int)
    {
      SliceIterator ans = *this;
      m_Pos++;
      return ans;
    }



  TPixel& operator[](unsigned long n)
    { return this->Loc(m_Pos=n); }



  TPixel& operator*()
    { return Loc(m_Pos); }



  bool operator==(const SliceIterator &orig)
    {
      return orig.m_Pos==this->m_Pos
        && orig.m_Slice.stride()==this->m_Slice.stride()
        && orig.m_Slice.start() ==this->m_Slice.start();
    }


  bool operator!=(const SliceIterator &orig)
    {
      return ! operator==(orig);
    }




  bool operator<(const SliceIterator &orig)
    {
      return this->m_Pos < orig.m_Pos
        && this->m_Slice.stride()==orig.m_Slice.stride()
        && this->m_Slice.start()==orig.m_Slice.start();
    }

private:

  TPixel& Loc(unsigned long n) const
    {
      const unsigned long start = static_cast<unsigned long>( m_Slice.start() );
      const unsigned long stride = static_cast<unsigned long>( m_Slice.stride() );
      return (*m_ContainerPointer)[ start + n * stride ];
    }


  TContainer *m_ContainerPointer;


  unsigned long m_Pos;


  std::slice m_Slice;
};

}
# 25 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.h" 2




namespace itk {
# 52 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.h"
template<class TPixel, unsigned int VDimension = 2,
         class TAllocator = NeighborhoodAllocator<TPixel> >
class Neighborhood
{
public:

  typedef Neighborhood Self;


  typedef TAllocator AllocatorType;


  static const unsigned int NeighborhoodDimension = VDimension;


  typedef TPixel PixelType;




  typedef typename AllocatorType::iterator Iterator;
  typedef typename AllocatorType::const_iterator ConstIterator;


  typedef Size<VDimension> SizeType;
  typedef typename SizeType::SizeValueType SizeValueType;


  typedef Size<VDimension> RadiusType;


  typedef Offset<VDimension> OffsetType;


  typedef SliceIterator<TPixel, Self> SliceIteratorType;


  Neighborhood() { m_Radius.Fill(0); m_Size.Fill(0); }


  virtual ~Neighborhood() {}


  Neighborhood(const Self& other);


  Self &operator=(const Self& other);


  bool
  operator==(const Self& other) const
  {
    return (m_Radius == other.m_Radius &&
            m_Size == other.m_Size &&
            m_DataBuffer == other.m_DataBuffer);
  }


  bool operator!=(const Self& other) const
  {
    return (m_Radius != other.m_Radius ||
            m_Size != other.m_Size ||
            m_DataBuffer != other.m_DataBuffer);
  }


  const SizeType GetRadius() const
    { return m_Radius; }



  unsigned long GetRadius(const unsigned long n) const
    { return m_Radius[n]; }



  unsigned long GetSize(const unsigned long n) const
    { return m_Size[n]; }


  SizeType GetSize() const
    { return m_Size; }




  unsigned GetStride(const unsigned axis) const
  { return m_StrideTable[axis]; }


  Iterator End()
    { return m_DataBuffer.end(); }
  Iterator Begin()
    { return m_DataBuffer.begin(); }
  ConstIterator End() const
    { return m_DataBuffer.end(); }
  ConstIterator Begin() const
    { return m_DataBuffer.begin(); }


  unsigned int Size() const
    { return m_DataBuffer.size(); }


  TPixel &operator[](unsigned int i)
    { return m_DataBuffer[i]; }
  const TPixel &operator[](unsigned int i) const
  { return m_DataBuffer[i]; }
  TPixel &GetElement(unsigned int i)
  { return m_DataBuffer[i]; }


  TPixel GetCenterValue() const
  { return (this->operator[]((this->Size())>>1)); }



  void SetRadius(const SizeType &);



  void SetRadius(const unsigned long *rad)
  {
    SizeType s;
    memcpy(s.m_Size, rad, sizeof(unsigned long) * VDimension);
    this->SetRadius(s);
  }




  void SetRadius(const unsigned long);


  void Print(std::ostream& os) const
    { this->PrintSelf(os, Indent(0)); }


  AllocatorType &GetBufferReference()
    { return m_DataBuffer; }
  const AllocatorType &GetBufferReference() const
    { return m_DataBuffer; }


  TPixel &operator[](const OffsetType &o)
  { return this->operator[](this->GetNeighborhoodIndex(o)); }
  const TPixel &operator[](const OffsetType &o) const
  { return this->operator[](this->GetNeighborhoodIndex(o)); }



  virtual OffsetType GetOffset(unsigned int i) const
  { return m_OffsetTable[i]; }

  virtual unsigned int GetNeighborhoodIndex(const OffsetType &) const;

  unsigned int GetCenterNeighborhoodIndex() const
  { return static_cast<unsigned int>(this->Size()/2); }

  std::slice GetSlice(unsigned int) const;

protected:

  void SetSize()
  {
    if (false) { } else for (unsigned int i=0; i<VDimension; ++i)
      { m_Size[i] = m_Radius[i]*2+1; }
  }


  virtual void Allocate(unsigned int i)
    { m_DataBuffer.set_size(i); }


  virtual void PrintSelf(std::ostream&, Indent) const;


  virtual void ComputeNeighborhoodStrideTable();



  virtual void ComputeNeighborhoodOffsetTable();

private:


  SizeType m_Radius;



  SizeType m_Size;


  AllocatorType m_DataBuffer;



  unsigned int m_StrideTable[VDimension];


  std::vector<OffsetType> m_OffsetTable;

};

template <class TPixel, unsigned int VDimension, class TContainer>
std::ostream & operator<<(std::ostream &os, const Neighborhood<TPixel,VDimension,TContainer> &neighborhood)
{
  os << "Neighborhood:" << std::endl;
  os << "    Radius:" << neighborhood.GetRadius() << std::endl;
  os << "    Size:" << neighborhood.GetSize() << std::endl;
  os << "    DataBuffer:" << neighborhood.GetBufferReference() << std::endl;

  return os;
}

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.txx"
#define _itkNeighborhood_txx 
namespace itk {

template<class TPixel, unsigned int VDimension, class TContainer>
void
Neighborhood<TPixel, VDimension, TContainer>
::ComputeNeighborhoodStrideTable()
{
  unsigned stride, accum;

  if (false) { } else for (unsigned int dim = 0; dim < VDimension; ++dim)
    {
    stride = 0;
    accum = 1;

    if (false) { } else for (unsigned int i=0; i<VDimension; ++i)
      {
      if (i == dim) stride = accum;
      accum *= m_Size[i];
      }

    m_StrideTable[dim] = stride;
    }
}

template<class TPixel, unsigned int VDimension, class TContainer>
void Neighborhood<TPixel, VDimension, TContainer>
::ComputeNeighborhoodOffsetTable()
{
  m_OffsetTable.clear();
  m_OffsetTable.reserve(this->Size());
  OffsetType o;
  unsigned int i, j;
  if (false) { } else for (j = 0; j < VDimension; j++)
    {
    o[j] = -(static_cast<long>(this->GetRadius(j)));
    }

  if (false) { } else for (i = 0; i < this->Size(); ++i)
    {
    m_OffsetTable.push_back(o);
    if (false) { } else for (j= 0; j< VDimension; j++)
      {
      o[j] = o[j] + 1;
      if (o[j] > static_cast<long>(this->GetRadius(j)))
        {
        o[j] = -(static_cast<long>(this->GetRadius(j)));
        }
      else break;
      }
    }
}

template<class TPixel, unsigned int VDimension, class TContainer>
void
Neighborhood<TPixel, VDimension, TContainer>
::SetRadius(const unsigned long s)
{
  SizeType k;
  if (false) { } else for (unsigned int i = 0; i< VDimension; i++)
    {
    k[i] = s;
    }
  this->SetRadius(k);
}

template<class TPixel, unsigned int VDimension, class TContainer>
void
Neighborhood<TPixel, VDimension, TContainer>
::SetRadius(const SizeType &r)
{
  memcpy(m_Radius.m_Size, r.m_Size, sizeof(const unsigned long)*VDimension);
  this->SetSize();

  unsigned int cumul=1;
  if (false) { } else for (unsigned int i = 0; i<VDimension; i++)
    {
    cumul*=m_Size[i];
    }

  this->Allocate(cumul);
  this->ComputeNeighborhoodStrideTable();
  this->ComputeNeighborhoodOffsetTable();
}

template<class TPixel, unsigned int VDimension, class TContainer>
Neighborhood<TPixel, VDimension, TContainer>
::Neighborhood(const Self &other)
{
  m_Radius = other.m_Radius;
  m_Size = other.m_Size;
  m_DataBuffer = other.m_DataBuffer;
  ::memcpy(m_StrideTable, other.m_StrideTable, sizeof(unsigned int) * VDimension);
  m_OffsetTable = other.m_OffsetTable;
}


template<class TPixel, unsigned int VDimension, class TContainer>
Neighborhood<TPixel, VDimension, TContainer> &
Neighborhood<TPixel, VDimension, TContainer>
::operator=(const Self &other)
{
  m_Radius = other.m_Radius;
  m_Size = other.m_Size;
  m_DataBuffer = other.m_DataBuffer;
  ::memcpy(m_StrideTable, other.m_StrideTable, sizeof(unsigned int) * VDimension);
  m_OffsetTable = other.m_OffsetTable;
  return *this;
}



template<class TPixel, unsigned int VDimension, class TContainer>
std::slice Neighborhood<TPixel, VDimension, TContainer>
::GetSlice(unsigned int d) const
{
  unsigned int n = this->Size()/2;
  n = n - ( static_cast<unsigned>(this->GetStride(d))
            * (static_cast<unsigned>(this->GetSize()[d] / 2) ) );

  return std::slice(static_cast<size_t>(n),
                    static_cast<size_t>(this->GetSize()[d]),
                    static_cast<size_t>(this->GetStride(d)) );
}

template<class TPixel, unsigned int VDimension, class TContainer>
unsigned int Neighborhood<TPixel, VDimension, TContainer>
::GetNeighborhoodIndex(const OffsetType &o) const
{
  unsigned int idx = (this->Size()/2);
  if (false) { } else for (unsigned i = 0; i < VDimension; ++i)
    { idx+=o[i] * static_cast<long>(m_StrideTable[i]); }
  return idx;
}


template<class TPixel, unsigned int VDimension, class TContainer>
void Neighborhood<TPixel, VDimension, TContainer>
::PrintSelf(std::ostream &os, Indent indent) const
{
  unsigned int i;

  os << indent << "m_Size: [ ";
  if (false) { } else for (i=0; i<VDimension; ++i) os << m_Size[i] << " ";
  os << "]" << std::endl;

  os << indent << "m_Radius: [ ";
  if (false) { } else for (i=0; i<VDimension; ++i) os << m_Radius[i] << " ";
  os << "]" << std::endl;

  os << indent << "m_StrideTable: [ ";
  if (false) { } else for (i=0; i<VDimension; ++i) os << m_StrideTable[i] << " ";
  os << "]" << std::endl;

  os << indent << "m_OffsetTable: [ ";
  if (false) { } else for (i=0; i< m_OffsetTable.size(); ++i) os << m_OffsetTable[i] << " ";
  os << "]" << std::endl;
}

}
# 271 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhood.h" 2
# 30 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageBoundaryCondition.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageBoundaryCondition.h"
#define __itkImageBoundaryCondition_h_ 






namespace itk
{
# 51 "/tmp/installed/include/InsightToolkit/Common/itkImageBoundaryCondition.h"
template <class TImageType>
class ImageBoundaryCondition
{
public:

  static const unsigned int ImageDimension = TImageType::ImageDimension;



  typedef ImageBoundaryCondition Self;


  typedef typename TImageType::PixelType PixelType;
  typedef typename TImageType::InternalPixelType *PixelPointerType;
  typedef Index<(Self::ImageDimension)> IndexType;
  typedef Offset<(Self::ImageDimension)> OffsetType;


  typedef Neighborhood<PixelPointerType,
                      (Self::ImageDimension)> NeighborhoodType;


  ImageBoundaryCondition() {}





  virtual PixelType operator()(const OffsetType& point_index,
                               const OffsetType &boundary_offset,
                                 const NeighborhoodType *data) const = 0;
};

}
# 31 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkExceptionObject.h" 1
# 32 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.h"
#define __itkZeroFluxNeumannBoundaryCondition_h 



namespace itk
{
# 57 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.h"
template<class TImage>
class ZeroFluxNeumannBoundaryCondition
  : public ImageBoundaryCondition<TImage>
{
public:

  typedef ZeroFluxNeumannBoundaryCondition Self;
  typedef ImageBoundaryCondition<TImage> Superclass;


  typedef typename Superclass::PixelType PixelType;
  typedef typename Superclass::PixelPointerType PixelPointerType;
  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::OffsetType OffsetType;
  typedef typename Superclass::NeighborhoodType NeighborhoodType;


  static const unsigned int ImageDimension = Superclass::ImageDimension;


  ZeroFluxNeumannBoundaryCondition() {}



  virtual PixelType operator()(const OffsetType& point_index,
                               const OffsetType& boundary_offset,
                               const NeighborhoodType *data) const;
};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.txx"
#define __itkZeroFluxNeumannBoundaryCondition_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.h" 1
# 20 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.txx" 2
namespace itk
{
template<class TImage>
typename ZeroFluxNeumannBoundaryCondition<TImage>::PixelType
ZeroFluxNeumannBoundaryCondition<TImage>
::operator()(const OffsetType& point_index, const OffsetType& boundary_offset,
             const NeighborhoodType *data) const
{
  int linear_index = 0;


  if (false) { } else for (unsigned int i = 0; i < ImageDimension; ++i)
    {
    linear_index += (point_index[i] + boundary_offset[i]) * data->GetStride(i);
    }

  return *(data->operator[](linear_index));
}

}
# 90 "/tmp/installed/include/InsightToolkit/Common/itkZeroFluxNeumannBoundaryCondition.h" 2
# 33 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h" 2

namespace itk {
# 50 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h"
template<class TImage, class TBoundaryCondition
                       = ZeroFluxNeumannBoundaryCondition<TImage> >
class ConstNeighborhoodIterator
  : public Neighborhood<typename TImage::InternalPixelType *,
                         ::itk::GetImageDimension<TImage>::ImageDimension>
{
public:

  typedef typename TImage::InternalPixelType InternalPixelType;
  typedef typename TImage::PixelType PixelType;


  static const unsigned int Dimension = TImage::ImageDimension;


  typedef ConstNeighborhoodIterator Self;
  typedef Neighborhood<InternalPixelType *, (Self::Dimension)> Superclass;


  typedef typename Superclass::OffsetType OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;
  typedef typename Superclass::RadiusType RadiusType;
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;
  typedef typename Superclass::Iterator Iterator;
  typedef typename Superclass::ConstIterator ConstIterator;


  typedef TImage ImageType;
  typedef typename TImage::RegionType RegionType;
  typedef Index<(Self::Dimension)> IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;
  typedef Neighborhood<PixelType, (Self::Dimension)> NeighborhoodType;


  typedef TBoundaryCondition BoundaryConditionType;


  typedef ImageBoundaryCondition<ImageType> *ImageBoundaryConditionPointerType;
  typedef ImageBoundaryCondition<ImageType> const *ImageBoundaryConditionConstPointerType;


  ConstNeighborhoodIterator();


  virtual ~ConstNeighborhoodIterator() {}


  ConstNeighborhoodIterator( const ConstNeighborhoodIterator & );



  ConstNeighborhoodIterator(const SizeType &radius,
                       const ImageType * ptr,
                       const RegionType &region
                       )
  {
    this->Initialize(radius, ptr, region);
    if (false) { } else for (unsigned int i=0; i < Dimension; i++)
      { m_InBounds[i] = false; }
    this->ResetBoundaryCondition();
  }


  Self &operator=(const Self& orig);


  virtual void PrintSelf(std::ostream &, Indent) const;



  OffsetType ComputeInternalIndex(unsigned int n) const;


  IndexType GetBound() const
    { return m_Bound; }



  long GetBound(unsigned int n) const
    { return m_Bound[n]; }


  const InternalPixelType *GetCenterPointer() const
    { return (this->operator[]((this->Size())>>1)); }


  PixelType GetCenterPixel() const
    { return *( this->GetCenterPointer() ); }


  const ImageType * GetImagePointer(void) const
    { return m_ConstImage; }



  virtual IndexType GetIndex(void) const
    { return m_Loop; }



  virtual NeighborhoodType GetNeighborhood() const;


  virtual PixelType GetPixel(const unsigned i) const
    { bool inbounds; return this->GetPixel(i, inbounds); }






  virtual PixelType GetPixel(const unsigned i, bool& IsInBounds) const;



  virtual PixelType GetPixel(const OffsetType &o) const
  { bool inbounds; return (this->GetPixel(this->GetNeighborhoodIndex(o), inbounds)); }






  virtual PixelType GetPixel(const OffsetType &o,
                             bool& IsInBounds) const
  { return (this->GetPixel(this->GetNeighborhoodIndex(o), IsInBounds)); }




  virtual PixelType GetNext(const unsigned axis, const unsigned i) const
  { return (this->GetPixel(this->GetCenterNeighborhoodIndex()
                           + (i * this->GetStride(axis)))); }




  virtual PixelType GetNext(const unsigned axis) const
  { return (this->GetPixel(this->GetCenterNeighborhoodIndex()
                           + this->GetStride(axis))); }




  virtual PixelType GetPrevious(const unsigned axis, const unsigned i) const
  { return (this->GetPixel(this->GetCenterNeighborhoodIndex()
                           - (i * this->GetStride(axis)))); }




  virtual PixelType GetPrevious(const unsigned axis) const
  { return (this->GetPixel(this->GetCenterNeighborhoodIndex()
                           - this->GetStride(axis))); }



  virtual IndexType GetIndex(const OffsetType &o) const
  { return (this->GetIndex() + o); }



  virtual IndexType GetIndex(const unsigned i) const
  { return (this->GetIndex() + this->GetOffset(i)); }


  RegionType GetRegion() const
    { return m_Region; }



  IndexType GetBeginIndex() const
    { return m_BeginIndex; }



  RegionType GetBoundingBoxAsImageRegion() const;


  OffsetType GetWrapOffset() const
    { return m_WrapOffset; }






  OffsetValueType GetWrapOffset(unsigned int n) const
    { return m_WrapOffset[n]; }




  virtual void GoToBegin();



  virtual void GoToEnd();



  virtual void Initialize(const SizeType &radius, const ImageType *ptr,
                          const RegionType &region);



  virtual bool IsAtBegin() const
    { return ( this->GetCenterPointer() == m_Begin ); }



  virtual bool IsAtEnd() const
    {
      if ( this->GetCenterPointer() > m_End )
        {
        ExceptionObject e("/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h", 266);
        OStringStream msg;
        msg << "In method IsAtEnd, CenterPointer = " << this->GetCenterPointer()
            << " is greater than End = " << m_End
            << std::endl
            << "  " << *this;
        e.SetDescription(msg.str().c_str());
        throw e;
        }
      return ( this->GetCenterPointer() == m_End );
    }





  Self &operator++();





  Self &operator--();




  bool operator==(const Self &it) const
    { return it.GetCenterPointer() == this->GetCenterPointer(); }




  bool operator!=(const Self &it) const
    { return it.GetCenterPointer() != this->GetCenterPointer(); }




  bool operator<(const Self &it) const
    { return this->GetCenterPointer() < it.GetCenterPointer(); }




  bool operator<=(const Self &it) const
    { return this->GetCenterPointer() <= it.GetCenterPointer(); }




  bool operator>(const Self &it) const
    { return this->GetCenterPointer() > it.GetCenterPointer(); }




  bool operator>=(const Self &it) const
    { return this->GetCenterPointer() >= it.GetCenterPointer(); }





  void SetLocation( const IndexType& position )
    {
      this->SetLoop(position);
      this->SetPixelPointers(position);
    }





  Self &operator+=(const OffsetType &);




  Self &operator-=(const OffsetType &);


  OffsetType operator-(const Self& b)
  { return m_Loop - b.m_Loop; }




  bool InBounds() const;






  virtual void OverrideBoundaryCondition(const ImageBoundaryConditionPointerType i)
    { m_BoundaryCondition = i; }



  virtual void ResetBoundaryCondition()
    { m_BoundaryCondition = &m_InternalBoundaryCondition; }


  void SetBoundaryCondition( const TBoundaryCondition &c )
  { m_InternalBoundaryCondition = c; }


  const BoundaryConditionType *GetBoundaryCondition() const
  { return dynamic_cast<BoundaryConditionType *>(m_BoundaryCondition); }


  void NeedToUseBoundaryConditionOn()
  {
    this->SetNeedToUseBoundaryCondition(true);
  }
  void NeedToUseBoundaryConditionOff()
  {
    this->SetNeedToUseBoundaryCondition(false);
  }
  void SetNeedToUseBoundaryCondition(bool b)
  {
    m_NeedToUseBoundaryCondition = b;
  }
  bool GetNeedToUseBoundaryCondition() const
  {
    return m_NeedToUseBoundaryCondition;
  }


protected:



  virtual void SetLoop( const IndexType& p )
    { m_Loop = p; }




  virtual void SetBound(const SizeType &);





  virtual void SetPixelPointers(const IndexType &);



  virtual void SetBeginIndex( const IndexType& start)
    { m_BeginIndex = start; }



  virtual void SetEndIndex();



  IndexType m_BeginIndex;


  IndexType m_Bound;


  const InternalPixelType *m_Begin;


  typename ImageType::ConstWeakPointer m_ConstImage;




  const InternalPixelType *m_End;



  IndexType m_EndIndex;


  IndexType m_Loop;


  RegionType m_Region;





  OffsetType m_WrapOffset;





  ImageBoundaryConditionPointerType m_BoundaryCondition;



  mutable bool m_InBounds[Dimension];


  IndexType m_InnerBoundsLow;


  IndexType m_InnerBoundsHigh;


  TBoundaryCondition m_InternalBoundaryCondition;


  bool m_NeedToUseBoundaryCondition;

};

template<class TImage>
inline ConstNeighborhoodIterator<TImage>
operator+(const ConstNeighborhoodIterator<TImage> &it,
          const typename ConstNeighborhoodIterator<TImage>
          ::OffsetType &ind)
{
  ConstNeighborhoodIterator<TImage> ret;
  ret = it;
  ret += ind;
  return ret;
}

template<class TImage>
inline ConstNeighborhoodIterator<TImage>
operator+(const typename ConstNeighborhoodIterator<TImage>
          ::OffsetType &ind,
          const ConstNeighborhoodIterator<TImage> &it)
{ return (it + ind); }

template<class TImage>
inline ConstNeighborhoodIterator<TImage>
operator-(const ConstNeighborhoodIterator<TImage> &it,
          const typename ConstNeighborhoodIterator<TImage>
          ::OffsetType &ind)
{
  ConstNeighborhoodIterator<TImage> ret;
  ret = it;
  ret -= ind;
  return ret;
}
# 524 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h"
}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.txx"
#define _itkConstNeighborhoodIterator_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h" 1
# 20 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.txx" 2
namespace itk {

template<class TImage, class TBoundaryCondition>
bool
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::InBounds() const
{
  bool ans = true;
  if (false) { } else for (unsigned int i=0; i<Dimension; i++)
    {
    if (m_Loop[i] < m_InnerBoundsLow[i] || m_Loop[i] >= m_InnerBoundsHigh[i])
      {
      m_InBounds[i] = ans = false;
      }
    else
      {
      m_InBounds[i] = true;
      }
    }
  return ans;
}



template<class TImage, class TBoundaryCondition>
typename ConstNeighborhoodIterator<TImage, TBoundaryCondition>::PixelType
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::GetPixel(const unsigned n, bool& IsInBounds) const
{



  if (!m_NeedToUseBoundaryCondition)
    {
    IsInBounds = true;
    return (*(this->operator[](n)));
    }

  register unsigned int i;
  OffsetValueType OverlapLow, OverlapHigh;
  OffsetType temp, offset;
  bool flag;


  if (this->InBounds())
    {
    IsInBounds = true;
    return (*(this->operator[](n)));
    }
  else
    {
    temp = this->ComputeInternalIndex(n);

    flag = true;


    if (false) { } else for (i=0; i<Dimension; ++i)
      {
      if (m_InBounds[i])
        {
        offset[i] = 0;
        }
      else
        {

        OverlapLow = m_InnerBoundsLow[i] - m_Loop[i];
        OverlapHigh =
          static_cast<OffsetValueType>(this->GetSize(i) - ( (m_Loop[i]+2) - m_InnerBoundsHigh[i] ));


        if (temp[i] < OverlapLow)
          {
          flag = false;
          offset[i] = OverlapLow - temp[i];
          }
        else if ( OverlapHigh < temp[i] )
          {
          flag = false;
          offset[i] = OverlapHigh - temp[i];
          }
        else offset[i] = 0;
        }
      }

    if (flag)
      {
      IsInBounds = true;
      return ( *(this->operator[](n)) ) ;
      }
    else
      {
      IsInBounds = false;
      return( m_BoundaryCondition->operator()(temp, offset, this) );
      }
    }
}


template<class TImage, class TBoundaryCondition>
typename ConstNeighborhoodIterator<TImage, TBoundaryCondition>::OffsetType
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::ComputeInternalIndex(unsigned int n) const
{
  OffsetType ans;
  long D = (long)Dimension;
  unsigned long r;
  r = (unsigned long)n;
  if (false) { } else for (long i = D-1; i >= 0 ; --i)
    {
    ans[i] = static_cast<OffsetValueType>(r / this->GetStride(i));
    r = r % this->GetStride(i);
    }
  return ans;
}


template <class TImage, class TBoundaryCondition>
typename ConstNeighborhoodIterator<TImage, TBoundaryCondition>::RegionType
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::GetBoundingBoxAsImageRegion() const
{
  RegionType ans;
  ans.SetIndex(this->GetIndex(0));
  ans.SetSize(this->GetSize());

  return ans;
}

template<class TImage, class TBoundaryCondition>
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::ConstNeighborhoodIterator()
{
  IndexType zeroIndex; zeroIndex.Fill(0);
  SizeType zeroSize; zeroSize.Fill(0);

  m_Bound.Fill(0);
  m_Begin = 0;
  m_BeginIndex.Fill(0);

  m_End = 0;
  m_EndIndex.Fill(0);
  m_Loop.Fill(0);
  m_Region.SetIndex(zeroIndex);
  m_Region.SetSize(zeroSize);

  m_WrapOffset.Fill(0);

  if (false) { } else for (unsigned int i=0; i < Dimension; i++)
    { m_InBounds[i] = false; }

  this->ResetBoundaryCondition();
}

template<class TImage, class TBoundaryCondition>
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::ConstNeighborhoodIterator(const Self& orig)
  : Neighborhood<InternalPixelType *, Dimension>(orig)
{
  m_Bound = orig.m_Bound;
  m_Begin = orig.m_Begin;
  m_BeginIndex = orig.m_BeginIndex;
  m_ConstImage = orig.m_ConstImage;
  m_End = orig.m_End;
  m_EndIndex = orig.m_EndIndex;
  m_Loop = orig.m_Loop;
  m_Region = orig.m_Region;
  m_WrapOffset = orig.m_WrapOffset;

  m_InternalBoundaryCondition = orig.m_InternalBoundaryCondition;
  m_NeedToUseBoundaryCondition = orig.m_NeedToUseBoundaryCondition;
  if (false) { } else for (unsigned int i = 0; i < Dimension; ++i)
    {
    m_InBounds[i] = orig.m_InBounds[i];
    }

  m_InnerBoundsLow = orig.m_InnerBoundsLow;
  m_InnerBoundsHigh = orig.m_InnerBoundsHigh;



  if ( orig.m_BoundaryCondition ==
       static_cast<ImageBoundaryConditionConstPointerType>(&orig.m_InternalBoundaryCondition ))
    {
    this->ResetBoundaryCondition();
    }
  else
    { m_BoundaryCondition = orig.m_BoundaryCondition; }

}

template<class TImage, class TBoundaryCondition>
void
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::SetEndIndex()
{
  if (m_Region.GetNumberOfPixels() > 0)
    {
    m_EndIndex = m_Region.GetIndex();
    m_EndIndex[Dimension-1] = m_Region.GetIndex()[Dimension-1] +
      static_cast<long>(m_Region.GetSize()[Dimension-1]);
    }
  else
    {

    m_EndIndex = m_Region.GetIndex();
    }
}

template<class TImage, class TBoundaryCondition>
typename ConstNeighborhoodIterator<TImage, TBoundaryCondition>::NeighborhoodType
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::GetNeighborhood() const
{
  register unsigned int i;
  OffsetType OverlapLow, OverlapHigh, temp, offset;
  bool flag;

  const ConstIterator _end = this->End();
  NeighborhoodType ans;
  typename NeighborhoodType::Iterator ans_it;
  ConstIterator this_it;

  ans.SetRadius( this->GetRadius() );

  if (m_NeedToUseBoundaryCondition == false)
    {
    if (false) { } else for (ans_it = ans.Begin(), this_it = this->Begin();
         this_it < _end; ans_it++, this_it++)
      { *ans_it = **this_it; }
    }
  else if (InBounds())
    {
    if (false) { } else for (ans_it = ans.Begin(), this_it = this->Begin();
         this_it < _end; ans_it++, this_it++)
      { *ans_it = **this_it; }
    }
  else
    {

    if (false) { } else for (i=0; i<Dimension; i++)
      {
      OverlapLow[i] = m_InnerBoundsLow[i] - m_Loop[i];
      OverlapHigh[i]=
        static_cast<OffsetValueType>(this->GetSize(i)) - ( (m_Loop[i]+2) - m_InnerBoundsHigh[i] );
      temp[i] = 0;
      }


    if (false) { } else for (ans_it = ans.Begin(), this_it = this->Begin();
         this_it < _end; ans_it++, this_it++)
      {
      flag = true;


      if (false) { } else for (i=0; i<Dimension; ++i)
        {
        if (m_InBounds[i]) offset[i] = 0;
        else
          {
          if (temp[i] < OverlapLow[i])
            {
            flag = false;
            offset[i] = OverlapLow[i] - temp[i];
            }
          else if ( OverlapHigh[i] < temp[i] )
            {
            flag = false;
            offset[i] = OverlapHigh[i] - temp[i];
            }
          else offset[i] = 0;
          }
        }

      if (flag) *ans_it = **this_it;
      else *ans_it = m_BoundaryCondition->operator()(temp, offset, this);

      if (false) { } else for (i=0; i<Dimension; ++i)
        {
        temp[i]++;
        if ( temp[i] == static_cast<OffsetValueType>(this->GetSize(i)) ) temp[i]= 0;
        else break;
        }
      }
    }
  return ans;
}

template<class TImage, class TBoundaryCondition>
void
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::GoToBegin()
{
  this->SetLocation( m_BeginIndex );
}

template<class TImage, class TBoundaryCondition>
void
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::GoToEnd()
{
  this->SetLocation( m_EndIndex );
}

template<class TImage, class TBoundaryCondition>
void ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::Initialize(const SizeType &radius, const ImageType *ptr,
             const RegionType &region)
{
  m_ConstImage = ptr;
  m_Region = region;
  const IndexType regionIndex = region.GetIndex();

  this->SetRadius(radius);
  this->SetBeginIndex(region.GetIndex());
  this->SetLocation(region.GetIndex());
  this->SetBound(region.GetSize());
  this->SetEndIndex();

  m_Begin = ptr->GetBufferPointer() + ptr->ComputeOffset(regionIndex);

  m_End = ptr->GetBufferPointer() + ptr->ComputeOffset( m_EndIndex );


  const IndexType bStart = ptr->GetBufferedRegion().GetIndex();
  const SizeType bSize = ptr->GetBufferedRegion().GetSize();
  const IndexType rStart = region.GetIndex();
  const SizeType rSize = region.GetSize();

  long overlapLow, overlapHigh;

  m_NeedToUseBoundaryCondition = false;
  if (false) { } else for (unsigned long i = 0; i < Dimension; ++i)
    {
    overlapLow = static_cast<long>((rStart[i] - radius[i]) - bStart[i]);
    overlapHigh= static_cast<long>((bStart[i] + bSize[i]) - (rStart[i] + rSize[i] + radius[i]));

    if (overlapLow < 0)
      {
      m_NeedToUseBoundaryCondition = true;
      break;
      }

    if (overlapHigh < 0)
      {
      m_NeedToUseBoundaryCondition = true;
      break;
      }
    }
}

template<class TImage, class TBoundaryCondition>
ConstNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::operator=(const Self& orig)
{
  Superclass::operator=(orig);

  m_Bound = orig.m_Bound;
  m_Begin = orig.m_Begin;
  m_ConstImage = orig.m_ConstImage;
  m_End = orig.m_End;
  m_EndIndex = orig.m_EndIndex;
  m_Loop = orig.m_Loop;
  m_Region = orig.m_Region;
  m_BeginIndex = orig.m_BeginIndex;
  m_WrapOffset = orig.m_WrapOffset;

  m_InternalBoundaryCondition = orig.m_InternalBoundaryCondition;
  m_NeedToUseBoundaryCondition = orig.m_NeedToUseBoundaryCondition;

  m_InnerBoundsLow = orig.m_InnerBoundsLow;
  m_InnerBoundsHigh = orig.m_InnerBoundsHigh;

  if (false) { } else for (unsigned int i = 0; i < Dimension; ++i)
    {
    m_InBounds[i] = orig.m_InBounds[i];
    }



  if (orig.m_BoundaryCondition ==
      static_cast<ImageBoundaryConditionConstPointerType>( &orig.m_InternalBoundaryCondition ) )
    {
    this->ResetBoundaryCondition();
    }
  else m_BoundaryCondition = orig.m_BoundaryCondition;

  return *this;
}

template<class TImage, class TBoundaryCondition>
ConstNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::operator++()
{
  unsigned int i;
  Iterator it;
  const Iterator _end = Superclass::End();


  if (false) { } else for (it = Superclass::Begin(); it < _end; ++it)
    {
    (*it)++;
    }


  if (false) { } else for (i=0; i<Dimension; ++i)
    {
    m_Loop[i]++;
    if ( m_Loop[i] == m_Bound[i] )
      {
      m_Loop[i] = m_BeginIndex[i];
      if (false) { } else for (it = Superclass::Begin(); it < _end; ++it)
        {
        (*it) += m_WrapOffset[i];
        }
      }
    else break;
    }
  return *this;
}

template<class TImage, class TBoundaryCondition>
ConstNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::operator--()
{
  unsigned int i;
  Iterator it;
  const Iterator _end = Superclass::End();


  if (false) { } else for (it = Superclass::Begin(); it < _end; ++it)
    {
    (*it)--;
    }


  if (false) { } else for (i=0; i<Dimension; ++i)
    {
    if (m_Loop[i] == m_BeginIndex[i])
      {
      m_Loop[i]= m_Bound[i] - 1;
      if (false) { } else for (it = Superclass::Begin(); it < _end; ++it)
        {
        (*it) -= m_WrapOffset[i];
        }
      }
    else
      {
      m_Loop[i]--;
      break;
      }
    }
  return *this;
}

template<class TImage, class TBoundaryCondition>
void
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::PrintSelf(std::ostream &os, Indent indent) const
{
  unsigned int i;
  os << indent;
  os << "ConstNeighborhoodIterator {this= " << this;
  os << ", m_Region = { Start = {";
  if (false) { } else for (i=0; i < Dimension; ++i) os << m_Region.GetIndex()[i] << " ";
  os << "}, Size = { ";
  if (false) { } else for (i=0; i < Dimension; ++i) os << m_Region.GetSize()[i] << " ";
  os << "} }";
  os << ", m_BeginIndex = { ";
  if (false) { } else for (i=0; i < Dimension; ++i) os << m_BeginIndex[i] << " ";
  os << "} , m_EndIndex = { ";
  if (false) { } else for (i=0; i < Dimension; ++i) os << m_EndIndex[i] << " ";
  os << "} , m_Loop = { ";
  if (false) { } else for (i=0; i < Dimension; ++i) os << m_Loop[i] << " ";
  os << "}, m_Bound = { ";
  if (false) { } else for (i=0; i < Dimension; ++i) os << m_Bound[i] << " ";
  os << "}, m_WrapOffset = { ";
  if (false) { } else for (i=0; i < Dimension; ++i) os << m_WrapOffset[i] << " ";
  os << ", m_Begin = " << m_Begin;
  os << ", m_End = " << m_End;
  os << "}" << std::endl;

  os << indent << ",  m_InnerBoundsLow = { ";
  if (false) { } else for (i = 0; i<Dimension; i++) os << m_InnerBoundsLow[i] << " ";
  os << "}, m_InnerBoundsHigh = { ";
  if (false) { } else for (i = 0; i<Dimension; i++) os << m_InnerBoundsHigh[i] << " ";
  os << "} }" << std::endl;
  Superclass::PrintSelf(os, indent.GetNextIndent());
}

template<class TImage, class TBoundaryCondition>
void ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::SetBound(const SizeType& size)
{
  SizeType radius = this->GetRadius();
  const OffsetValueType *offset = m_ConstImage->GetOffsetTable();
  const IndexType imageBRStart = m_ConstImage->GetBufferedRegion().GetIndex();
  SizeType imageBRSize = m_ConstImage->GetBufferedRegion().GetSize();




  if (false) { } else for (unsigned int i=0; i<Dimension; ++i)
    {
    m_Bound[i] = m_BeginIndex[i] + static_cast<IndexValueType>(size[i]);
    m_InnerBoundsHigh[i]= static_cast<IndexValueType>(imageBRStart[i] + ( imageBRSize[i]) - static_cast<SizeValueType>(radius[i]) );
    m_InnerBoundsLow[i] = static_cast<IndexValueType>(imageBRStart[i] + radius[i]);
    m_WrapOffset[i] = (static_cast<OffsetValueType>(imageBRSize[i]) - ( m_Bound[i]
                                                                                - m_BeginIndex[i] )) * offset[i];
    }
  m_WrapOffset[Dimension-1] = 0;

}


template<class TImage, class TBoundaryCondition>
void ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::SetPixelPointers(const IndexType &pos)
{
  const Iterator _end = Superclass::End();
  InternalPixelType * Iit;
  ImageType *ptr = const_cast<ImageType *>(m_ConstImage.GetPointer());
  const SizeType size = this->GetSize();
  const OffsetValueType *OffsetTable = m_ConstImage->GetOffsetTable();
  const SizeType radius = this->GetRadius();

  unsigned int i;
  Iterator Nit;
  SizeType loop;
  if (false) { } else for (i=0; i<Dimension; ++i) loop[i]=0;


  Iit = ptr->GetBufferPointer() + ptr->ComputeOffset(pos);

  if (false) { } else for (i = 0; i<Dimension; ++i)
    {
    Iit -= radius[i] * OffsetTable[i];
    }


  if (false) { } else for (Nit = Superclass::Begin(); Nit != _end; ++Nit)
    {
    *Nit = Iit;
    ++Iit;
    if (false) { } else for (i = 0; i <Dimension; ++i)
      {
      loop[i]++;
      if ( loop[i] == size[i] )
        {
        if (i==Dimension-1) break;
        Iit += OffsetTable[i+1] - OffsetTable[i] * static_cast<long>(size[i]);
        loop[i]= 0;
        }
      else break;
      }
    }
}

template<class TImage, class TBoundaryCondition>
ConstNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::operator+=(const OffsetType & idx)
{
  unsigned int i;
  Iterator it;
  const Iterator _end = this->End();
  OffsetValueType accumulator = 0;
  const OffsetValueType* stride = this->GetImagePointer()->GetOffsetTable();


  accumulator += idx[0];






  if (false) { } else for (i = 1; i< Dimension; ++i)
    {
    accumulator += idx[i] * stride[i];
    }


  if (false) { } else for (it = this->Begin(); it < _end; ++it)
    {
    (*it) += accumulator;
    }


  m_Loop += idx;

  return *this;
}

template<class TImage, class TBoundaryCondition>
ConstNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstNeighborhoodIterator<TImage, TBoundaryCondition>
::operator-=(const OffsetType & idx)
{
  unsigned int i;
  Iterator it;
  const Iterator _end = this->End();
  OffsetValueType accumulator = 0;
  const OffsetValueType* stride = this->GetImagePointer()->GetOffsetTable();


  accumulator += idx[0];






  if (false) { } else for (i = 1; i< Dimension; ++i)
    {
    accumulator += idx[i] * stride[i];
    }


  if (false) { } else for (it = this->Begin(); it < _end; ++it)
    {
    (*it) -= accumulator;
    }


  m_Loop -= idx;

  return *this;
}



}
# 529 "/tmp/installed/include/InsightToolkit/Common/itkConstNeighborhoodIterator.h" 2
# 24 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.h" 2

namespace itk {
# 209 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.h"
template<class TImage, class TBoundaryCondition
                       = ZeroFluxNeumannBoundaryCondition<TImage> >
class NeighborhoodIterator
  : public ConstNeighborhoodIterator<TImage,TBoundaryCondition>
{
public:

  typedef NeighborhoodIterator Self;
  typedef ConstNeighborhoodIterator<TImage,TBoundaryCondition> Superclass;


  typedef typename Superclass::InternalPixelType InternalPixelType;
  typedef typename Superclass::PixelType PixelType;
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::ImageType ImageType;
  typedef typename Superclass::RegionType RegionType;
  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::OffsetType OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;
  typedef typename Superclass::RadiusType RadiusType;
  typedef typename Superclass::NeighborhoodType NeighborhoodType;
  typedef typename Superclass::Iterator Iterator;
  typedef typename Superclass::ConstIterator ConstIterator;
  typedef typename Superclass::ImageBoundaryConditionPointerType
   ImageBoundaryConditionPointerType;


  NeighborhoodIterator(): Superclass() {}


  NeighborhoodIterator( const NeighborhoodIterator &n )
    : Superclass(n) {}


  Self &operator=(const Self& orig)
    {
      Superclass::operator=(orig);
      return *this;
    }



  NeighborhoodIterator(const SizeType &radius, ImageType * ptr,
                       const RegionType &region)
    : Superclass(radius, ptr, region) { }


  virtual void PrintSelf(std::ostream &, Indent) const;


  InternalPixelType *GetCenterPointer()
    { return (this->operator[]((this->Size())>>1)); }


  virtual void SetCenterPixel(const PixelType &p)
  { *( this->GetCenterPointer() ) = p; }




  virtual void SetNeighborhood(const NeighborhoodType &);



  virtual void SetPixel(const unsigned i, const PixelType &v,
                        bool &status);


  virtual void SetPixel(const unsigned i, const PixelType &v);



  virtual void SetPixel(const OffsetType o, const PixelType &v)
  { this->SetPixel(this->GetNeighborhoodIndex(o), v); }





  virtual void SetNext(const unsigned axis, const unsigned i,
                            const PixelType &v)
  { this->SetPixel(this->GetCenterNeighborhoodIndex()
                     + (i * this->GetStride(axis)), v); }





  virtual void SetNext(const unsigned axis, const PixelType &v)
    { this->SetPixel(this->GetCenterNeighborhoodIndex()
                       + this->GetStride(axis), v); }




  virtual void SetPrevious(const unsigned axis, const unsigned i,
                                const PixelType &v)
    { this->SetPixel(this->GetCenterNeighborhoodIndex()
                     - (i * this->GetStride(axis)), v); }





  virtual void SetPrevious(const unsigned axis,
                                const PixelType &v)
    { this->SetPixel(this->GetCenterNeighborhoodIndex()
                     - this->GetStride(axis), v); }

};

}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.txx"
#define _itkNeighborhoodIterator_txx 
namespace itk {

template<class TImage, class TBoundaryCondition>
void
NeighborhoodIterator<TImage, TBoundaryCondition>
::SetPixel(const unsigned n, const PixelType& v)
{
  register unsigned int i;
  OffsetType OverlapLow, OverlapHigh, temp, offset;
  bool flag;

  if (this->m_NeedToUseBoundaryCondition == false)
    { *(this->operator[](n)) = v; }


  else if (this->InBounds()) *(this->operator[](n)) = v;
  else
    {
    temp = this->ComputeInternalIndex(n);


    if (false) { } else for (i=0; i<this->Dimension; i++)
      {
      OverlapLow[i] = this->m_InnerBoundsLow[i] - this->m_Loop[i];
      OverlapHigh[i]=
        static_cast<OffsetValueType>(this->GetSize(i)
                                     - ( (this->m_Loop[i]+2) - this->m_InnerBoundsHigh[i]) );
      }

    flag = true;


    if (false) { } else for (i=0; i<this->Dimension; ++i)
      {
      if (this->m_InBounds[i]) offset[i] = 0;
      else
        {
        if (temp[i] < OverlapLow[i])
          {
          flag = false;
          offset[i] = OverlapLow[i] - temp[i];
          }
        else if ( OverlapHigh[i] < temp[i] )
          {
          flag = false;
          offset[i] = OverlapHigh[i] - temp[i];
          }
        else offset[i] = 0;
        }
      }

    if (flag)
      {
      *(this->operator[](n)) = v;
      }
    else
      {
      throw RangeError("/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.txx", 76);
      };
    }
}

template<class TImage, class TBoundaryCondition>
void
NeighborhoodIterator<TImage, TBoundaryCondition>
::SetPixel(const unsigned n, const PixelType& v, bool &status)
{
  register unsigned int i;
  OffsetType temp;

  typename OffsetType::OffsetValueType OverlapLow, OverlapHigh;

  if (this->m_NeedToUseBoundaryCondition == false)
    {
    status = true;
    *(this->operator[](n)) = v;
    }


  else if (this->InBounds())
    {
    *(this->operator[](n)) = v;
    status = true;
    return;
    }
  else
    {
    temp = this->ComputeInternalIndex(n);





    if (false) { } else for (i=0; i<this->Dimension; i++)
      {
      if (! this->m_InBounds[i])
        {
        OverlapLow = this->m_InnerBoundsLow[i] - this->m_Loop[i];
        OverlapHigh=
          static_cast<OffsetValueType>(this->GetSize(i)
                                       - ( (this->m_Loop[i]+2) - this->m_InnerBoundsHigh[i]) );
        if (temp[i] < OverlapLow || OverlapHigh < temp[i])
          {
          status = false;
          return;
          }
        }
      }

    *(this->operator[](n)) = v ;
    status = true;
    }
}


template<class TImage, class TBoundaryCondition>
void
NeighborhoodIterator<TImage, TBoundaryCondition>
::PrintSelf(std::ostream &os, Indent indent) const
{
  os << indent;
  os << "NeighborhoodIterator {this= " << this << "}" << std::endl;
  Superclass::PrintSelf(os, indent.GetNextIndent());
}

template<class TImage, class TBoundaryCondition>
void
NeighborhoodIterator<TImage, TBoundaryCondition>
::SetNeighborhood(const NeighborhoodType &N)
{
  register unsigned int i;
  OffsetType OverlapLow, OverlapHigh, temp;
  bool flag;

  const Iterator _end = this->End();
  Iterator this_it;
  typename NeighborhoodType::ConstIterator N_it;

  if (this->m_NeedToUseBoundaryCondition == false)
    {
    if (false) { } else for (N_it = N.Begin(), this_it = this->Begin(); this_it < _end;
         this_it++, N_it++)
      {
      **this_it = *N_it;
      }
    }
  else if (this->InBounds())
    {
    if (false) { } else for (N_it = N.Begin(), this_it = this->Begin(); this_it < _end;
         this_it++, N_it++)
      {
      **this_it = *N_it;
      }
    }
  else
    {

    if (false) { } else for (i=0; i<this->Dimension; i++)
      {
      OverlapLow[i] =this->m_InnerBoundsLow[i] - this->m_Loop[i];
      OverlapHigh[i]=
        static_cast<OffsetValueType>(this->GetSize(i) - (this->m_Loop[i]-this->m_InnerBoundsHigh[i])-1);
      temp[i] = 0;
      }


    if (false) { } else for (N_it = N.Begin(), this_it = this->Begin();
         this_it < _end; N_it++, this_it++)
      {
      flag = true;
      if (false) { } else for (i=0; i<this->Dimension; ++i)
        {
        if (!this->m_InBounds[i] && ((temp[i] < OverlapLow[i])
                               || (temp[i] >= OverlapHigh[i])) )
          {
          flag=false;
          break;
          }
        }

      if (flag)
        {
        **this_it = *N_it;
        }

      if (false) { } else for (i=0; i<this->Dimension; ++i)
        {
        temp[i]++;
        if ( (unsigned int)(temp[i]) == this->GetSize(i) ) temp[i]= 0;
        else break;
        }
      }

    }
}

}
# 325 "/tmp/installed/include/InsightToolkit/Common/itkNeighborhoodIterator.h" 2
# 23 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.h" 2

namespace itk {
# 67 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.h"
template<class TImage, class TBoundaryCondition
                       = ZeroFluxNeumannBoundaryCondition<TImage> >
class ConstShapedNeighborhoodIterator
  : private NeighborhoodIterator<TImage, TBoundaryCondition>
{
public:

  typedef typename TImage::InternalPixelType InternalPixelType;
  typedef typename TImage::PixelType PixelType;


  static const unsigned int Dimension = TImage::ImageDimension;


  typedef ConstShapedNeighborhoodIterator Self;
  typedef NeighborhoodIterator<TImage, TBoundaryCondition> Superclass;


  typedef typename Superclass::OffsetType OffsetType;
  typedef typename OffsetType::OffsetValueType OffsetValueType;
  typedef typename Superclass::RadiusType RadiusType;
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;


  typedef TImage ImageType;
  typedef typename TImage::RegionType RegionType;
  typedef Index<(Self::Dimension)> IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;
  typedef Neighborhood<PixelType, (Self::Dimension)> NeighborhoodType;



  typedef std::list<unsigned int> IndexListType;


  typedef TBoundaryCondition BoundaryConditionType;


  typedef ImageBoundaryCondition<ImageType> *ImageBoundaryConditionPointerType;


  struct ConstIterator
  {
    ConstIterator() { this->m_NeighborhoodIterator = 0; }
    ConstIterator(Self *s)
    {
      this->m_NeighborhoodIterator = s;
      this->GoToBegin();
    }
    ~ConstIterator() {}
    const ConstIterator &operator=(const ConstIterator &o)
    {
      this->m_NeighborhoodIterator = o.m_NeighborhoodIterator;
      this->m_ListIterator = o.m_ListIterator;
      return *this;
    }

    ConstIterator(const ConstIterator &o)
    {
      this->m_NeighborhoodIterator = o.m_NeighborhoodIterator;
      this->m_ListIterator = o.m_ListIterator;
    }

    void operator++(int)
    { this->m_ListIterator++; }

    void operator--(int)
    { this->m_ListIterator--; }

    const ConstIterator &operator++()
    {
      this->m_ListIterator++;
      return *this;
    }
    const ConstIterator &operator--()
    {
      this->m_ListIterator--;
      return *this;
    }

    bool operator!=(const ConstIterator &o) const
    { return this->m_ListIterator.operator!=(o.m_ListIterator); }
    bool operator==(const ConstIterator &o) const
    { return this->m_ListIterator.operator==(o.m_ListIterator); }

    bool IsAtEnd() const
    {
      if (this->m_ListIterator == this->m_NeighborhoodIterator->GetActiveIndexList().end())
        { return true; }
      else { return false; }
    }

    void GoToBegin()
    {
      this->m_ListIterator = this->m_NeighborhoodIterator->GetActiveIndexList().begin();
    }

    void GoToEnd()
    {
      this->m_ListIterator = this->m_NeighborhoodIterator->GetActiveIndexList().end();
    }

    PixelType Get() const
    { return this->m_NeighborhoodIterator->GetPixel(*this->m_ListIterator); }

    OffsetType GetNeighborhoodOffset() const
    { return this->m_NeighborhoodIterator->GetOffset(*this->m_ListIterator); }

    typename IndexListType::value_type GetNeighborhoodIndex() const
    { return *this->m_ListIterator; }

  protected:
    Self *m_NeighborhoodIterator;
    typename IndexListType::const_iterator m_ListIterator;

    void ProtectedSet(const PixelType &v) const
    { this->m_NeighborhoodIterator->SetPixel(*this->m_ListIterator, v); }
  };



  const ConstIterator &Begin() const
  { return this->m_ConstBeginIterator; }



  const ConstIterator &End() const
  { return this->m_ConstEndIterator; }


  ConstShapedNeighborhoodIterator()
  {
    this->m_ConstBeginIterator = ConstIterator(this);
    this->m_ConstEndIterator = ConstIterator(this);
    this->m_ConstEndIterator.GoToEnd();
    this->m_CenterIsActive = false;
  }


  virtual ~ConstShapedNeighborhoodIterator() { }



  ConstShapedNeighborhoodIterator(const SizeType &radius,
                       const ImageType * ptr,
                       const RegionType &region
                                  ) : Superclass (radius, const_cast<ImageType*>(ptr),
                                                  region)
  {
    this->m_ConstBeginIterator = ConstIterator(this);
    this->m_ConstEndIterator = ConstIterator(this);
    this->m_ConstEndIterator.GoToEnd();
    this->m_CenterIsActive = false;
  }



  Superclass::GetImagePointer;
  Superclass::GetRadius;
  Superclass::GetIndex;
  Superclass::GetNeighborhoodIndex;
  Superclass::GetCenterNeighborhoodIndex;
  Superclass::GetRegion;
  Superclass::GetBeginIndex;
  Superclass::GoToBegin;
  Superclass::GoToEnd;
  Superclass::IsAtBegin;
  Superclass::IsAtEnd;
  Superclass::GetOffset;
  Superclass::operator==;
  Superclass::operator!=;
  Superclass::operator<;
  Superclass::operator>;
  Superclass::operator>=;
  Superclass::operator<=;
  Superclass::operator[];
  Superclass::GetElement;
  Superclass::SetLocation;
  Superclass::OverrideBoundaryCondition;
  Superclass::ResetBoundaryCondition;
  Superclass::GetBoundaryCondition;
  Superclass::Print;

  Superclass::operator-;

  Superclass::GetPixel;


  Self &operator=(const Self& orig)
  {
    Superclass::operator=(orig);
    this->m_ActiveIndexList = orig.m_ActiveIndexList;
    this->m_CenterIsActive = orig.m_CenterIsActive;


    this->m_ConstBeginIterator.GoToBegin();
    this->m_ConstEndIterator.GoToBegin();
    return *this;
  }


  virtual void PrintSelf(std::ostream &, Indent) const;




  virtual void ActivateOffset(const OffsetType& off)
  { this->ActivateIndex( Superclass::GetNeighborhoodIndex(off) ); }
  virtual void DeactivateOffset(const OffsetType& off)
  { this->DeactivateIndex( Superclass::GetNeighborhoodIndex(off) ); }


  virtual void ClearActiveList()
  {
    this->m_ActiveIndexList.clear();
    this->m_ConstBeginIterator.GoToBegin();
    this->m_ConstEndIterator.GoToEnd();
    this->m_CenterIsActive = false;
  }


  const IndexListType &GetActiveIndexList() const
  { return this->m_ActiveIndexList; }


  typename IndexListType::size_type GetActiveIndexListSize() const
  { return this->m_ActiveIndexList.size(); }



  Self &operator++();



  Self &operator--();




  Self &operator+=(const OffsetType &);




  Self &operator-=(const OffsetType &);



  Superclass::SetPixel;
protected:

  ConstShapedNeighborhoodIterator( const ConstShapedNeighborhoodIterator & );


  friend struct ConstIterator;
# 333 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.h"
  virtual void ActivateIndex(const unsigned int);
  virtual void DeactivateIndex(const unsigned int);

  bool m_CenterIsActive;
  IndexListType m_ActiveIndexList;
  ConstIterator m_ConstEndIterator;
  ConstIterator m_ConstBeginIterator;
};


}



# 1 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.txx"
#define _itkConstShapedNeighborhoodIterator_txx 
# 1 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.h" 1
# 20 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.txx" 2
namespace itk {


template<class TImage, class TBoundaryCondition>
void
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
::PrintSelf(std::ostream &os, Indent indent) const
{
  os << indent << "ConstShapedNeighborhoodIterator {this = " << this;
  os << " m_ActiveIndexList = [";
  if (false) { } else for (IndexListType::const_iterator it = this->m_ActiveIndexList.begin();
       it != this->m_ActiveIndexList.end(); ++it)
    { os << *it << " "; }
  os << "] ";
  os << " m_CenterIsActive = " << this->m_CenterIsActive;
  os << "}" << std::endl;
  Superclass::PrintSelf(os, indent.GetNextIndent());
}

template<class TImage, class TBoundaryCondition>
void
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
::ActivateIndex(const unsigned int n)
{
  const OffsetValueType *OffsetTable = this->m_ConstImage->GetOffsetTable();


  IndexListType::iterator it = this->m_ActiveIndexList.begin();

  if (this->m_ActiveIndexList.empty()) { this->m_ActiveIndexList.push_front(n); }
  else
    {
    while (n > *it)
      {
      it++;
      if (it == this->m_ActiveIndexList.end()) { break; }
      }
    if (it == this->m_ActiveIndexList.end())
      { this->m_ActiveIndexList.insert(it, n); }
    else if (n != *it)
      { this->m_ActiveIndexList.insert(it, n); }
    }


  this->m_ConstBeginIterator.GoToBegin();
  this->m_ConstEndIterator.GoToEnd();


  if ( n == this->GetCenterNeighborhoodIndex() )
    { this->m_CenterIsActive = true; }


  this->GetElement(n) = this->GetCenterPointer();
  if (false) { } else for (unsigned i = 0; i < this->Dimension; ++i)
    { this->GetElement(n) += OffsetTable[i] * this->GetOffset(n)[i]; }
}

template<class TImage, class TBoundaryCondition>
void
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
::DeactivateIndex(const unsigned int n)
{
  IndexListType::iterator it = this->m_ActiveIndexList.begin();

  if (this->m_ActiveIndexList.empty()) return;
  else
    {
    while (n != *it)
      {
      it++;
      if (it == this->m_ActiveIndexList.end()) return;
      }
    this->m_ActiveIndexList.erase(it);
    }


  this->m_ConstBeginIterator.GoToBegin();
  this->m_ConstEndIterator.GoToEnd();


  if ( n == this->GetCenterNeighborhoodIndex() )
    { this->m_CenterIsActive = false; }
}


template<class TImage, class TBoundaryCondition>
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
::operator++()
{
  unsigned int i;
  IndexListType::const_iterator it;


  if (! this->m_CenterIsActive)
    {
    this->GetElement(
      this->GetCenterNeighborhoodIndex()
      )++; }


  if (false) { } else for (it = this->m_ActiveIndexList.begin(); it != this->m_ActiveIndexList.end(); it++)
    { (this->GetElement(*it))++; }


  if (false) { } else for (i=0; i<Dimension; ++i)
    {
    this->m_Loop[i]++;
    if ( this->m_Loop[i] == this->m_Bound[i] )
      {
      this->m_Loop[i] = this->m_BeginIndex[i];
      if (! this->m_CenterIsActive)
        { this->GetElement(this->GetCenterNeighborhoodIndex())+= this->m_WrapOffset[i]; }
      if (false) { } else for (it = this->m_ActiveIndexList.begin(); it != this->m_ActiveIndexList.end(); it++)
        { (this->GetElement(*it))+= this->m_WrapOffset[i]; }
      }
    else break;
    }
  return *this;
}

template<class TImage, class TBoundaryCondition>
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
::operator--()
{
  unsigned int i;
  IndexListType::const_iterator it;


  if (! this->m_CenterIsActive) { this->GetElement(this->GetCenterNeighborhoodIndex())--; }


  if (false) { } else for (it = this->m_ActiveIndexList.begin(); it != this->m_ActiveIndexList.end(); it++)
    { (this->GetElement(*it))--; }


  if (false) { } else for (i=0; i<this->Dimension; ++i)
    {
    if (this->m_Loop[i] == this->m_BeginIndex[i])
      {
      this->m_Loop[i]= this->m_Bound[i] - 1;
      if (! this->m_CenterIsActive)
        { this->GetElement(this->GetCenterNeighborhoodIndex())-= this->m_WrapOffset[i]; }
      if (false) { } else for (it = this->m_ActiveIndexList.begin(); it != this->m_ActiveIndexList.end(); it++)
        { (this->GetElement(*it))-= this->m_WrapOffset[i]; }
      }
    else
      {
      this->m_Loop[i]--;
      break;
      }
    }
  return *this;
}

template<class TImage, class TBoundaryCondition>
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
::operator+=(const OffsetType & idx)
{
  unsigned int i;
  IndexListType::const_iterator it;
  OffsetValueType accumulator = 0;
  const OffsetValueType* stride = this->GetImagePointer()->GetOffsetTable();


  accumulator += idx[0];






  if (false) { } else for (i = 1; i< this->Dimension; ++i)
    {
    accumulator += idx[i] * stride[i];
    }


  if (! this->m_CenterIsActive)
    { this->GetElement(this->GetCenterNeighborhoodIndex())+= accumulator; }


  if (false) { } else for (it = this->m_ActiveIndexList.begin(); it != this->m_ActiveIndexList.end(); it++)
    { (this->GetElement(*it))+= accumulator ; }


  this->m_Loop += idx;

  return *this;
}

template<class TImage, class TBoundaryCondition>
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition> &
ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
::operator-=(const OffsetType & idx)
{
  unsigned int i;
  IndexListType::const_iterator it;
  OffsetValueType accumulator = 0;
  const OffsetValueType* stride = this->GetImagePointer()->GetOffsetTable();


  accumulator += idx[0];






  if (false) { } else for (i = 1; i< Dimension; ++i)
    {
    accumulator += idx[i] * stride[i];
    }


  if (! m_CenterIsActive)
    { this->GetElement(this->GetCenterNeighborhoodIndex()) -= accumulator; }


  if (false) { } else for (it = this->m_ActiveIndexList.begin(); it != this->m_ActiveIndexList.end(); it++)
    { (this->GetElement(*it)) -= accumulator ; }


  this->m_Loop -= idx;

  return *this;
}

}
# 348 "/tmp/installed/include/InsightToolkit/Common/itkConstShapedNeighborhoodIterator.h" 2
# 27 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.txx" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkConstantBoundaryCondition.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkConstantBoundaryCondition.h"
#define __itkConstantBoundaryCondition_h 




namespace itk
{
# 56 "/tmp/installed/include/InsightToolkit/Common/itkConstantBoundaryCondition.h"
template<class TImage>
class ConstantBoundaryCondition
  : public ImageBoundaryCondition<TImage>
{
public:

  typedef ConstantBoundaryCondition Self;
  typedef ImageBoundaryCondition<TImage> Superclass;


  typedef typename Superclass::PixelType PixelType;
  typedef typename Superclass::PixelPointerType PixelPointerType;
  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::OffsetType OffsetType;
  typedef typename Superclass::NeighborhoodType NeighborhoodType;


  static const unsigned int ImageDimension = Superclass::ImageDimension;


  ConstantBoundaryCondition()
    { m_Constant = NumericTraits<PixelType>::Zero; }



  virtual PixelType operator()(const OffsetType&,
                               const OffsetType&,
                               const NeighborhoodType *) const
    { return m_Constant; }


  void SetConstant(const PixelType &c)
    { m_Constant = c; }


  const PixelType &GetConstant() const
    { return m_Constant; }

private:
  PixelType m_Constant;
};

}
# 28 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.txx" 2



namespace itk
{
template< class TInputImage, class TOutputImage >
void
ConnectedComponentImageFilter< TInputImage, TOutputImage >
::GenerateInputRequestedRegion()
{

  Superclass::GenerateInputRequestedRegion();


  InputImagePointer input = const_cast<InputImageType *>(this->GetInput());

  input->SetRequestedRegion( input->GetLargestPossibleRegion() );
}



template <class TInputImage, class TOutputImage>
void
ConnectedComponentImageFilter<TInputImage, TOutputImage>
::EnlargeOutputRequestedRegion(DataObject *)
{
  this->GetOutput()
    ->SetRequestedRegion( this->GetOutput()->GetLargestPossibleRegion() );
}


template< class TInputImage, class TOutputImage >
void
ConnectedComponentImageFilter< TInputImage, TOutputImage >
::GenerateData()
{

  EquivalencyTable::Pointer eqTable = EquivalencyTable::New();

  OutputPixelType label, originalLabel, neighborLabel;
  OutputPixelType maxLabel = NumericTraits<OutputPixelType>::Zero;
  const OutputPixelType maxPossibleLabel=NumericTraits<OutputPixelType>::max();

  typename TOutputImage::Pointer output = this->GetOutput();
  typename TInputImage::ConstPointer input = this->GetInput();


  this->AllocateOutputs();
  output->FillBuffer( NumericTraits<OutputPixelType>::Zero );


  ConstantBoundaryCondition<TOutputImage> BC;
  BC.SetConstant(NumericTraits<OutputPixelType>::Zero);




  typedef ConstShapedNeighborhoodIterator<TOutputImage> NeighborhoodIteratorType;
  SizeType kernelRadius;
  kernelRadius.Fill(1);
  NeighborhoodIteratorType nit;
  nit = NeighborhoodIteratorType(kernelRadius, output,
                               output->GetRequestedRegion());
  nit.OverrideBoundaryCondition(&BC);





  unsigned int d;
  typename NeighborhoodIteratorType::OffsetType offset;

  if (!m_FullyConnected)
    {


    offset.Fill(0);
    if (false) { } else for (d=0; d < InputImageType::ImageDimension; ++d)
      {
      offset[d] = -1;
      nit.ActivateOffset(offset);
      offset[d] = 0;
      }
    }
  else
    {


    unsigned int centerIndex = nit.GetCenterNeighborhoodIndex();
    if (false) { } else for (d=0; d < centerIndex; d++)
      {
      offset = nit.GetOffset(d);
      nit.ActivateOffset(offset);
      }
    }



  ImageRegionConstIterator<InputImageType> it;
  ImageRegionIterator<OutputImageType> oit;
  it = ImageRegionConstIterator<InputImageType>(input,
                                                output->GetRequestedRegion());
  oit = ImageRegionIterator<OutputImageType>(output,
                                             output->GetRequestedRegion());




  ProgressReporter progress(this, 0,
                           3*output->GetRequestedRegion().GetNumberOfPixels());


  it.GoToBegin();
  oit.GoToBegin();
  while (!it.IsAtEnd())
    {
    if (it.Get() != NumericTraits<InputPixelType>::Zero)
      {

      oit.Set(maxPossibleLabel);
      }

    ++it;
    ++oit;
    progress.CompletedPixel();
    }





  nit.GoToBegin();
  oit.GoToBegin();
  while ( !oit.IsAtEnd() )
    {

    label = oit.Get();
    originalLabel = label;


    if (label != NumericTraits<OutputPixelType>::Zero)
      {


      typename NeighborhoodIteratorType::ConstIterator sIt;
      if (false) { } else for (sIt = nit.Begin(); !sIt.IsAtEnd(); ++sIt)
        {


        neighborLabel = sIt.Get();



        if (neighborLabel != NumericTraits<OutputPixelType>::Zero)
          {

          if (label == maxPossibleLabel)
            {

            label = neighborLabel;
            }





          else if ((label != neighborLabel)
                && (eqTable->Lookup(label) != eqTable->Lookup(neighborLabel)))
            {
            eqTable->Add(label, neighborLabel);




            eqTable->Flatten();
            }
          }
        }


      if (originalLabel == label)
        {

        if (maxLabel == maxPossibleLabel)
          {
          { if (itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "WARNING: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.txx" ", line " << 213 << "\n" << this->GetNameOfClass() << " (" << this << "): " << "ConnectedComponentImageFilter::GenerateData: Number of labels exceeds number of available labels for the output type." << "\n\n"; itk::OutputWindowDisplayWarningText(itkmsg.str().c_str());} };
          }
        else
          {
          ++maxLabel;
          }


        label = maxLabel;
        }


      if (label != originalLabel)
        {
        oit.Set( label );
        }
      }


    ++nit;
    ++oit;
    progress.CompletedPixel();
    }


  eqTable->Flatten();


  oit.GoToBegin();
  while ( !oit.IsAtEnd() )
    {
    label = oit.Get();

    if (label != NumericTraits<OutputPixelType>::Zero)
      {
      oit.Set( eqTable->Lookup( label ) );
      }
    ++oit;
    progress.CompletedPixel();
    }
}

template< class TInputImage, class TOutputImage >
void
ConnectedComponentImageFilter< TInputImage, TOutputImage >
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  os << indent << "FullyConnected: " << m_FullyConnected << std::endl;
}

}
# 146 "/tmp/installed/include/InsightToolkit/BasicFilters/itkConnectedComponentImageFilter.h" 2
# 3 "../src/PerSliceConnectedComponentImageFilter.txx" 2


template <class TInputImage, class TOutputImage>
PerSliceConnectedComponentImageFilter<TInputImage, TOutputImage>
::PerSliceConnectedComponentImageFilter()
  : Superclass()
{
}


template <class TInputImage, class TOutputImage>
void
PerSliceConnectedComponentImageFilter<TInputImage, TOutputImage>
::ProcessSlice(SliceNumberType slice_number)
{
  typedef itk::ConnectedComponentImageFilter<InputSliceImageType, OutputSliceImageType> ConnectedFilterType;

  InputSliceImagePointer input_slice = GetInputSlice(slice_number);
  typename ConnectedFilterType::Pointer connected_filter = ConnectedFilterType::New();
  connected_filter->SetInput(input_slice);
  connected_filter->SetFullyConnected(true);
  connected_filter->Update();
  SetOutputSlice(connected_filter->GetOutput(), slice_number);
}
# 63 "../src/PerSliceConnectedComponentImageFilter.h" 2
# 2 "/home/peter/work/spineseg/test/PerSliceConnectedComponentImageFilterTest.cpp" 2
# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.h"
#define __itkImageRegionIteratorWithIndex_h 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.h" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.h"
#define __itkImageRegionConstIteratorWithIndex_h 



namespace itk
{
# 122 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.h"
template<typename TImage>
class ImageRegionConstIteratorWithIndex : public ImageConstIteratorWithIndex<TImage>
{
public:

  typedef ImageRegionConstIteratorWithIndex Self;
  typedef ImageConstIteratorWithIndex<TImage> Superclass;





  typedef typename TImage::IndexType IndexType;





  typedef TImage ImageType;




  typedef typename TImage::PixelContainer PixelContainer;
  typedef typename PixelContainer::Pointer PixelContainerPointer;





  typedef typename TImage::RegionType RegionType;


  ImageRegionConstIteratorWithIndex() : ImageConstIteratorWithIndex<TImage>() {}



  ImageRegionConstIteratorWithIndex( const TImage *ptr,
                                  const RegionType& region )
    : ImageConstIteratorWithIndex<TImage>(ptr, region) {}







  ImageRegionConstIteratorWithIndex( const ImageConstIteratorWithIndex<TImage> &it)
    { this->ImageConstIteratorWithIndex<TImage>::operator=(it); }
# 179 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.h"
  Self & operator++();
# 188 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.h"
  Self & operator--();
};





}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.txx"
#define _itkImageRegionConstIteratorWithIndex_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.txx" 2

namespace itk
{




template<class TImage>
ImageRegionConstIteratorWithIndex<TImage> &
ImageRegionConstIteratorWithIndex<TImage>
::operator++()
{

  this->m_Remaining = false;
  if (false) { } else for( unsigned int in=0; in<TImage::ImageDimension; in++ )
    {
    this->m_PositionIndex[ in ]++;
    if( this->m_PositionIndex[ in ] < this->m_EndIndex[ in ] )
      {
      this->m_Position += this->m_OffsetTable[in];
      this->m_Remaining = true;
      break;
      }
    else
      {
      this->m_Position -= this->m_OffsetTable[ in ]
        * ( static_cast<long>(this->m_Region.GetSize()[in])-1 );
      this->m_PositionIndex[ in ] = this->m_BeginIndex[ in ];
      }
    }

  if( !this->m_Remaining )
    {
    this->m_Position = this->m_End;
    }

  return *this;
}





template<class TImage>
ImageRegionConstIteratorWithIndex<TImage> &
ImageRegionConstIteratorWithIndex<TImage>
::operator--()
{

  this->m_Remaining = false;
  if (false) { } else for( unsigned int in=0; in<TImage::ImageDimension; in++ )
    {

    if( this->m_PositionIndex[ in ] > this->m_BeginIndex[ in ] )
      {
      this->m_PositionIndex[ in ]--;
      this->m_Position -= this->m_OffsetTable[in];
      this->m_Remaining = true;
      break;
      }
    else
      {
      this->m_PositionIndex[ in ]--;
      this->m_Position += this->m_OffsetTable[ in ]
        * ( static_cast<long>(this->m_Region.GetSize()[in])-1 );
      this->m_PositionIndex[ in ] = this->m_EndIndex[ in ] - 1;
      }

    }

  if( !this->m_Remaining )
    {
    this->m_Position = this->m_End;
    }

  return *this;
}

}
# 199 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionConstIteratorWithIndex.h" 2
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.h" 2


namespace itk
{
# 64 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.h"
template<typename TImage>
class ImageRegionIteratorWithIndex : public ImageRegionConstIteratorWithIndex<TImage>
{
public:

  typedef ImageRegionIteratorWithIndex Self;
  typedef ImageRegionConstIteratorWithIndex<TImage> Superclass;


  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::IndexValueType IndexValueType;
  typedef typename Superclass::SizeType SizeType;
  typedef typename Superclass::SizeValueType SizeValueType;
  typedef typename Superclass::OffsetType OffsetType;
  typedef typename Superclass::OffsetValueType OffsetValueType;
  typedef typename Superclass::RegionType RegionType;
  typedef typename Superclass::ImageType ImageType;
  typedef typename Superclass::PixelContainer PixelContainer;
  typedef typename Superclass::PixelContainerPointer PixelContainerPointer;
  typedef typename Superclass::InternalPixelType InternalPixelType;
  typedef typename Superclass::PixelType PixelType;
  typedef typename Superclass::AccessorType AccessorType;



  ImageRegionIteratorWithIndex();



  ImageRegionIteratorWithIndex(TImage *ptr, const RegionType& region);







  ImageRegionIteratorWithIndex( const ImageIteratorWithIndex<TImage> &it);


  void Set( const PixelType & value) const
    { this->m_PixelAccessor.Set(*(const_cast<InternalPixelType *>(this->m_Position)),value); }




  PixelType & Value(void)
    { return *(const_cast<InternalPixelType *>(this->m_Position)); }

protected:


  ImageRegionIteratorWithIndex( const ImageRegionConstIteratorWithIndex<TImage> &it);
  Self &operator=(const ImageRegionConstIteratorWithIndex<TImage> & it);

};

}


# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.txx" 1
# 18 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.txx"
#define _itkImageRegionIteratorWithIndex_txx 

# 1 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.h" 1
# 21 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.txx" 2

namespace itk
{


template< typename TImage >
ImageRegionIteratorWithIndex<TImage>
::ImageRegionIteratorWithIndex()
  : ImageRegionConstIteratorWithIndex<TImage>()
{


}



template< typename TImage >
ImageRegionIteratorWithIndex<TImage>
::ImageRegionIteratorWithIndex(TImage *ptr, const RegionType& region)
  : ImageRegionConstIteratorWithIndex<TImage>(ptr, region)
{


}



template< typename TImage >
ImageRegionIteratorWithIndex<TImage>
::ImageRegionIteratorWithIndex( const ImageIteratorWithIndex<TImage> &it):
  ImageRegionConstIteratorWithIndex<TImage>(it)
{
}


template< typename TImage >
ImageRegionIteratorWithIndex<TImage>
::ImageRegionIteratorWithIndex( const ImageRegionConstIteratorWithIndex<TImage> &it):
  ImageRegionConstIteratorWithIndex<TImage>(it)
{
}


template< typename TImage >
ImageRegionIteratorWithIndex<TImage> &
ImageRegionIteratorWithIndex<TImage>
::operator=( const ImageRegionConstIteratorWithIndex<TImage> &it)
{
  this->ImageRegionConstIteratorWithIndex<TImage>::operator=(it);
  return *this;
}



}
# 125 "/tmp/installed/include/InsightToolkit/Common/itkImageRegionIteratorWithIndex.h" 2
# 3 "/home/peter/work/spineseg/test/PerSliceConnectedComponentImageFilterTest.cpp" 2
# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h" 1
# 21 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h"
#define __itkRandomImageSource_h 




namespace itk
{
# 39 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h"
template <typename TOutputImage>
class RandomImageSource : public ImageSource<TOutputImage>
{
public:

  typedef RandomImageSource Self;
  typedef ImageSource<TOutputImage> Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;


  typedef typename TOutputImage::PixelType OutputImagePixelType;


  typedef typename TOutputImage::RegionType OutputImageRegionType;


  virtual const char *GetNameOfClass() const {return "RandomImageSource";};


  static Pointer New(void) { Pointer smartPtr; Self *rawPtr = ::itk::ObjectFactory<Self>::Create(); if(rawPtr == __null) { rawPtr = new Self; } smartPtr = rawPtr; rawPtr->UnRegister(); return smartPtr; } virtual ::itk::LightObject::Pointer CreateAnother(void) const { ::itk::LightObject::Pointer smartPtr; smartPtr = Self::New().GetPointer(); return smartPtr; };


  virtual void SetSize(unsigned long data[]) { unsigned int i; if (false) { } else for (i=0; i<TOutputImage::ImageDimension; i++) { if ( data[i] != this->m_Size[i] ) { break; }} if ( i < TOutputImage::ImageDimension ) { this->Modified(); if (false) { } else for (i=0; i<TOutputImage::ImageDimension; i++) { this->m_Size[i] = data[i]; } } };


  virtual unsigned long *GetSize () const { return this->m_Size; };


  virtual void SetSpacing(float data[]) { unsigned int i; if (false) { } else for (i=0; i<TOutputImage::ImageDimension; i++) { if ( data[i] != this->m_Spacing[i] ) { break; }} if ( i < TOutputImage::ImageDimension ) { this->Modified(); if (false) { } else for (i=0; i<TOutputImage::ImageDimension; i++) { this->m_Spacing[i] = data[i]; } } };


  virtual float *GetSpacing () const { return this->m_Spacing; };


  virtual void SetOrigin(float data[]) { unsigned int i; if (false) { } else for (i=0; i<TOutputImage::ImageDimension; i++) { if ( data[i] != this->m_Origin[i] ) { break; }} if ( i < TOutputImage::ImageDimension ) { this->Modified(); if (false) { } else for (i=0; i<TOutputImage::ImageDimension; i++) { this->m_Origin[i] = data[i]; } } };


  virtual float *GetOrigin () const { return this->m_Origin; };



  virtual void SetMin (OutputImagePixelType _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h" ", line " << 83 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " << "Min" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_Min != (_arg<NumericTraits<OutputImagePixelType>::NonpositiveMin()?NumericTraits<OutputImagePixelType>::NonpositiveMin():(_arg>NumericTraits<OutputImagePixelType>::max()?NumericTraits<OutputImagePixelType>::max():_arg))) { this->m_Min = (_arg<NumericTraits<OutputImagePixelType>::NonpositiveMin()?NumericTraits<OutputImagePixelType>::NonpositiveMin():(_arg>NumericTraits<OutputImagePixelType>::max()?NumericTraits<OutputImagePixelType>::max():_arg)); this->Modified(); } };




  virtual OutputImagePixelType GetMin () { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h" ", line " << 86 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "Min" " of " << this->m_Min << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_Min; };



  virtual void SetMax (OutputImagePixelType _arg) { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h" ", line " << 92 << "\n" << this->GetNameOfClass() << " (" << this << "): " "setting " << "Max" " to " << _arg << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; if (this->m_Max != (_arg<NumericTraits<OutputImagePixelType>::NonpositiveMin()?NumericTraits<OutputImagePixelType>::NonpositiveMin():(_arg>NumericTraits<OutputImagePixelType>::max()?NumericTraits<OutputImagePixelType>::max():_arg))) { this->m_Max = (_arg<NumericTraits<OutputImagePixelType>::NonpositiveMin()?NumericTraits<OutputImagePixelType>::NonpositiveMin():(_arg>NumericTraits<OutputImagePixelType>::max()?NumericTraits<OutputImagePixelType>::max():_arg)); this->Modified(); } };




  virtual OutputImagePixelType GetMax () { { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h" ", line " << 95 << "\n" << this->GetNameOfClass() << " (" << this << "): " "returning " << "Max" " of " << this->m_Max << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} }; return this->m_Max; };

protected:
  RandomImageSource();
  ~RandomImageSource();
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void
  ThreadedGenerateData(const OutputImageRegionType&
                       outputRegionForThread, int threadId );
  virtual void GenerateOutputInformation();

private:
  RandomImageSource(const RandomImageSource&);
  void operator=(const RandomImageSource&);

  unsigned long *m_Size;
  float *m_Spacing;
  float *m_Origin;

  typename TOutputImage::PixelType m_Min;
  typename TOutputImage::PixelType m_Max;
};

}


# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.txx" 1
# 21 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.txx"
#define _itkRandomImageSource_txx 

# 1 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h" 1
# 24 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.txx" 2



# 1 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_sample.h" 1


#define vnl_sample_h_ 
# 12 "/tmp/installed/include/InsightToolkit/Utilities/vxl/core/vnl/vnl_sample.h"
void vnl_sample_reseed();


void vnl_sample_reseed(int seed);


double vnl_sample_uniform(double a, double b);


void vnl_sample_normal_2(double *x, double *y);


double vnl_sample_normal(double mean, double sigma);







template <class I>
inline void vnl_sample_uniform(I begin, I end, double a, double b)
{
  if (false) { } else for (I p=begin; p!=end; ++p)
    (*p) = vnl_sample_uniform(a, b);
}


template <class I>
inline void vnl_sample_normal(I begin, I end, double mean, double sigma)
{
  if (false) { } else for (I p=begin; p!=end; ++p)
    (*p) = vnl_sample_normal(mean, sigma);
}
# 28 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.txx" 2


namespace itk
{




template <class TOutputImage>
RandomImageSource<TOutputImage>
::RandomImageSource()
{
  m_Size = new unsigned long [TOutputImage::GetImageDimension()];
  m_Spacing = new float [TOutputImage::GetImageDimension()];
  m_Origin = new float [TOutputImage::GetImageDimension()];


  if (false) { } else for (unsigned int i=0; i<TOutputImage::GetImageDimension(); i++)
    {
    m_Size[i] = 64;
    m_Spacing[i] = 1.0;
    m_Origin[i] = 0.0;
    }

  m_Min = NumericTraits<OutputImagePixelType>::NonpositiveMin();
  m_Max = NumericTraits<OutputImagePixelType>::max();
}

template <class TOutputImage>
RandomImageSource<TOutputImage>
::~RandomImageSource()
{
  delete [] m_Size;
  delete [] m_Spacing;
  delete [] m_Origin;
}




template <class TOutputImage>
void
RandomImageSource<TOutputImage>
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);
  os << indent << "Max: "
     << static_cast<typename NumericTraits<OutputImagePixelType>::PrintType>(m_Max)
     << std::endl;
  os << indent << "Min: "
     << static_cast<typename NumericTraits<OutputImagePixelType>::PrintType>(m_Min)
     << std::endl;
  unsigned int i;
  os << indent << "Origin: [";
  if (false) { } else for (i=0; i < TOutputImage::ImageDimension - 1; i++)
    {
    os << m_Origin[i] << ", ";
    }
  os << m_Origin[i] << "]" << std::endl;

  os << indent << "Spacing: [";
  if (false) { } else for (i=0; i < TOutputImage::ImageDimension - 1; i++)
    {
    os << m_Spacing[i] << ", ";
    }
  os << m_Spacing[i] << "]" << std::endl;

  os << indent << "Size: [";
  if (false) { } else for (i=0; i < TOutputImage::ImageDimension - 1; i++)
    {
    os << m_Size[i] << ", ";
    }
  os << m_Size[i] << "]" << std::endl;
}


template <typename TOutputImage>
void
RandomImageSource<TOutputImage>
::GenerateOutputInformation()
{
  TOutputImage *output;
  typename TOutputImage::IndexType index = {{0}};
  typename TOutputImage::SizeType size = {{0}};
  size.SetSize( m_Size );

  output = this->GetOutput(0);

  typename TOutputImage::RegionType largestPossibleRegion;
  largestPossibleRegion.SetSize( size );
  largestPossibleRegion.SetIndex( index );
  output->SetLargestPossibleRegion( largestPossibleRegion );

  output->SetSpacing(m_Spacing);
  output->SetOrigin(m_Origin);
}


template <typename TOutputImage>
void
RandomImageSource<TOutputImage>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                       int threadId )
{
  { if (this->GetDebug() && itk::Object::GetGlobalWarningDisplay()) { ::itk::OStringStream itkmsg; itkmsg << "Debug: In " "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.txx" ", line " << 132 << "\n" << this->GetNameOfClass() << " (" << this << "): " <<"Generating a random image of scalars" << "\n\n"; ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());} };


  ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels());

  typedef typename TOutputImage::PixelType scalarType;
  typename TOutputImage::Pointer image=this->GetOutput(0);

  ImageRegionIterator<TOutputImage> it(image, outputRegionForThread);


  unsigned long sample_seed = 12345 + threadId;
  double u;
  double rnd;

  double dMin = static_cast<double>(m_Min);
  double dMax = static_cast<double>(m_Max);

  if (false) { } else for ( ; !it.IsAtEnd(); ++it)
    {

    sample_seed = (sample_seed*16807)%2147483647L;
    u = static_cast<double>(sample_seed)/2147483711UL;
    rnd = (1.0 - u)*dMin + u*dMax;

    it.Set( (scalarType) rnd);
    progress.CompletedPixel();
    }
}

}
# 123 "/tmp/installed/include/InsightToolkit/BasicFilters/itkRandomImageSource.h" 2
# 4 "/home/peter/work/spineseg/test/PerSliceConnectedComponentImageFilterTest.cpp" 2


int PerSliceConnectedComponentImageFilterTest(int, char **)
{

  const unsigned int ImageDimension = 3;


  const unsigned int size = 5;

  const unsigned int slicing_direction = 1;


  typedef itk::Image<unsigned char, ImageDimension> InputImageType;
  typedef itk::Image<unsigned int, ImageDimension> OutputImageType;
  typedef InputImageType::PixelType InputPixelType;
  typedef OutputImageType::PixelType OutputPixelType;


  typedef itk::ImageRegionIteratorWithIndex<
                                  InputImageType> InputIteratorType;

  typedef itk::ImageRegionIteratorWithIndex<
                                  OutputImageType> OutputIteratorType;


  typedef itk::RandomImageSource<InputImageType> SourceType;
  SourceType::Pointer source = SourceType::New();

  unsigned long sizeArray[ImageDimension] = { size, size, size };

  source->SetMin( itk::NumericTraits<InputPixelType>::Zero );
  source->SetMax( itk::NumericTraits<InputPixelType>::One );
  source->SetSize( sizeArray );


  typedef PerSliceConnectedComponentImageFilter< InputImageType,
                               OutputImageType > FilterType;


  FilterType::Pointer filter = FilterType::New();


  filter->SetSlicingDirection(slicing_direction);

  filter->Print( std::cout );


  std::cout << "SlicingDirection: " << filter->GetSlicingDirection() << std::endl;


  InputImageType::Pointer input_image = source->GetOutput();
  filter->SetInput(input_image);


  OutputImageType::Pointer outputImage = filter->GetOutput();


  try
    {
    filter->Update();
    }
  catch(...)
    {
    std::cerr << "Caught an unexpected exception. " << std::endl;
    std::cerr << "Test failed. " << std::endl;
    return 1;
    }
# 169 "/home/peter/work/spineseg/test/PerSliceConnectedComponentImageFilterTest.cpp"
  std::cout << "Test passsed. " << std::endl;
  return 0;
}


int main(int argc, char ** argv)
{
  try {
    return PerSliceConnectedComponentImageFilterTest(argc, argv);
  } catch (std::exception & e) {
    printf("Exception caught: %s\n", e.what());
    return 99;
  } catch (...) {
    printf("Exception caught!");
    return 99;
  }
}