Preprocessed cregex.cpp from Boost 1.54

#1 "libs/regex/src/cregex.cpp"
#179 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/builtins.h"
typedef unsigned long __builtin_size_t ;
typedef unsigned long __builtin_ptrdiff_t ;
#243
//typedef struct {
//unsigned int __va_gp_offset ;
//unsigned int __va_fp_offset ;
//void * __va_overflow_arg_area ;
//void * __va_reg_sve_area ;
//} __sun_va_list [ 1 ] ;
#270
extern "C" {



void * __builtin_memcpy ( void * __dest , const void * __src , __builtin_size_t __n ) asm ( "memcpy" ) ;
void * __builtin_memset ( void * , int , __builtin_size_t ) asm ( "memset" ) ;
int __builtin_memcmp ( const void * , const void * , __builtin_size_t ) asm ( "memcmp" ) ;
void * __builtin_memchr ( const void * , int , __builtin_size_t ) asm ( "memchr" ) ;
void * __builtin_memmove ( void * __dest , const void * __src , __builtin_size_t __n ) asm ( "memmove" ) ;

static inline float __builtin_huge_valf ( ) ;
static inline double __builtin_huge_val ( ) ;
static inline long double __builtin_huge_vall ( ) ;

float __builtin_nanf ( const char * s ) asm ( "nanf" ) ;
long double __builtin_nanl ( const char * ) asm ( "nanl" ) ;
double __builtin_nan ( const char * ) asm ( "nan" ) ;

float __builtin_nansf ( const char * ) asm ( "nanf" ) ;
long double __builtin_nansl ( const char * ) asm ( "nanl" ) ;
double __builtin_nans ( const char * ) asm ( "nan" ) ;

static inline float __builtin_inff ( ) ;
static inline long double __builtin_infl ( ) ;
static inline double __builtin_inf ( ) ;


extern float __builtin_acosf ( float __x ) asm ( "acosf" ) ;
extern double __builtin_acos ( double __x ) asm ( "acos" ) ;
extern long double __builtin_acosl ( long double __x ) asm ( "acosl" ) ;

extern float __builtin_asinf ( float __x ) asm ( "asinf" ) ;
extern double __builtin_asin ( double __x ) asm ( "asin" ) ;
extern long double __builtin_asinl ( long double __x ) asm ( "asinl" ) ;

extern float __builtin_atan2f ( float __y , float __x ) asm ( "atan2f" ) ;
extern double __builtin_atan2 ( double __y , double __x ) asm ( "atan2" ) ;
extern long double __builtin_atan2l ( long double __y , long double __x ) asm ( "atan2l" ) ;

extern float __builtin_atanf ( float __x ) asm ( "atanf" ) ;
extern double __builtin_atan ( double __x ) asm ( "atan" ) ;
extern long double __builtin_atanl ( long double __x ) asm ( "atanl" ) ;

extern float __builtin_cosf ( float __x ) asm ( "cosf" ) ;
extern double __builtin_cos ( double __x ) asm ( "cos" ) ;
extern long double __builtin_cosl ( long double __x ) asm ( "cosl" ) ;

extern float __builtin_coshf ( float __x ) asm ( "coshf" ) ;
extern double __builtin_cosh ( double __x ) asm ( "cosh" ) ;
extern long double __builtin_coshl ( long double __x ) asm ( "coshl" ) ;

extern float __builtin_acoshf ( float __x ) ;
extern double __builtin_acosh ( double __x ) ;
extern long double __builtin_acoshl ( long double __x ) ;

extern float __builtin_sinf ( float __x ) asm ( "sinf" ) ;
extern double __builtin_sin ( double __x ) asm ( "sin" ) ;
extern long double __builtin_sinl ( long double __x ) asm ( "sinl" ) ;

extern float __builtin_sinhf ( float __x ) asm ( "sinhf" ) ;
extern double __builtin_sinh ( double __x ) asm ( "sinh" ) ;
extern long double __builtin_sinhl ( long double __x ) asm ( "sinhl" ) ;

extern float __builtin_asinhf ( float __x ) ;
extern double __builtin_asinh ( double __x ) ;
extern long double __builtin_asinhl ( long double __x ) ;

extern float __builtin_tanf ( float __x ) asm ( "tanf" ) ;
extern double __builtin_tan ( double __x ) asm ( "tan" ) ;
extern long double __builtin_tanl ( long double __x ) asm ( "tanl" ) ;

extern float __builtin_tanhf ( float __x ) asm ( "tanhf" ) ;
extern double __builtin_tanh ( double __x ) asm ( "tanh" ) ;
extern long double __builtin_tanhl ( long double __x ) asm ( "tanhl" ) ;

extern float __builtin_atanhf ( float __x ) ;
extern double __builtin_atanh ( double __x ) ;
extern long double __builtin_atanhl ( long double __x ) ;


extern long double __builtin_ceill ( long double __x ) asm ( "ceill" ) ;
extern double __builtin_ceil ( double __x ) asm ( "ceil" ) ;
extern float __builtin_ceilf ( float __x ) asm ( "ceilf" ) ;


extern long double __builtin_expl ( long double __x ) asm ( "expl" ) ;
extern double __builtin_exp ( double __x ) asm ( "exp" ) ;
extern float __builtin_expf ( float __x ) asm ( "expf" ) ;

extern double __builtin_exp2 ( double x ) ;
extern float __builtin_exp2f ( float x ) ;
extern long double __builtin_exp2l ( long double x ) ;

extern double __builtin_expm1 ( double x ) ;
extern float __builtin_expm1f ( float x ) ;
extern long double __builtin_expm1l ( long double x ) ;

extern long double __builtin_fabsl ( long double __x ) asm ( "fabsl" ) ;
extern double __builtin_fabs ( double __x ) asm ( "fabs" ) ;
extern float __builtin_fabsf ( float __x ) asm ( "fabsf" ) ;

extern long double __builtin_floorl ( long double __x ) asm ( "floorl" ) ;
extern double __builtin_floor ( double __x ) asm ( "floor" ) ;
extern float __builtin_floorf ( float __x ) asm ( "floorf" ) ;

extern long double __builtin_fmodl ( long double __x , long double __y ) asm ( "fmodl" ) ;
extern double __builtin_fmod ( double __x , double __y ) asm ( "fmod" ) ;
extern float __builtin_fmodf ( float __x , long double __y ) asm ( "fmodf" ) ;

extern double __builtin_fdim ( double x , double y ) ;
extern float __builtin_fdimf ( float x , float y ) ;
extern long double __builtin_fdiml ( long double x , long double y ) ;

extern double __builtin_fma ( double a , double b , double c ) ;
extern float __builtin_fmaf ( float a , float b , float c ) ;
extern long double __builtin_fmal ( long double a , long double b , long double c ) ;

extern double __builtin_fmax ( double x , double y ) ;
extern float __builtin_fmaxf ( float x , float y ) ;
extern long double __builtin_fmaxl ( long double x , long double y ) ;

extern double __builtin_fmin ( double x , double y ) ;
extern float __builtin_fminf ( float x , float y ) ;
extern long double __builtin_fminl ( long double x , long double y ) ;

extern long double __builtin_frexpl ( long double __x , int * __exponent ) asm ( "frexpl" ) ;
extern double __builtin_frexp ( double __x , int * __exponent ) asm ( "frexp" ) ;
extern float __builtin_frexpf ( float __x , int * __exponent ) asm ( "frexpf" ) ;

extern double __builtin_hypot ( double x , double y ) ;
extern float __builtin_hypotf ( float x , float y ) ;
extern long double __builtin_hypotl ( long double x , long double y ) ;

extern int __builtin_ilogb ( double x ) ;
extern int __builtin_ilogbf ( float x ) ;
extern int __builtin_ilogbl ( long double x ) ;

extern long double __builtin_ldexpl ( long double __x , int __exponent ) asm ( "ldexpl" ) ;
extern double __builtin_ldexp ( double __x , int __exponent ) asm ( "ldexp" ) ;
extern float __builtin_ldexpf ( float __x , int __exponent ) asm ( "ldexpf" ) ;

extern long int __builtin_lrint ( double x ) ;
extern long int __builtin_lrintf ( float x ) ;
extern long int __builtin_lrintl ( long double x ) ;

extern long int __builtin_lround ( double x ) ;
extern long int __builtin_lroundf ( float x ) ;
extern long int __builtin_lroundl ( long double x ) ;

extern long int __builtin_labs ( long ) asm ( "labs" ) ;
extern long long int __builtin_llabs ( long long ) asm ( "llabs" ) ;

extern long long int __builtin_llrint ( double x ) ;
extern long long int __builtin_llrintf ( float x ) ;
extern long long int __builtin_llrintl ( long double x ) ;

extern long long int __builtin_llround ( double x ) ;
extern long long int __builtin_llroundf ( float x ) ;
extern long long int __builtin_llroundl ( long double x ) ;

extern double __builtin_lgamma ( double x ) ;
extern float __builtin_lgammaf ( float x ) ;
extern long double __builtin_lgammal ( long double x ) ;

extern long double __builtin_log10l ( long double __x ) asm ( "log10l" ) ;
extern double __builtin_log10 ( double __x ) asm ( "log10" ) ;
extern float __builtin_log10f ( float __x ) asm ( "log10f" ) ;

extern long double __builtin_log2l ( long double __x ) ;
extern double __builtin_log2 ( double __x ) ;
extern float __builtin_log2f ( float __x ) ;

extern long double __builtin_logbl ( long double __x ) ;
extern double __builtin_logb ( double __x ) ;
extern float __builtin_logbf ( float __x ) ;

extern long double __builtin_log1pl ( long double __x ) ;
extern double __builtin_log1p ( double __x ) ;
extern float __builtin_log1pf ( float __x ) ;

extern long double __builtin_logl ( long double __x ) asm ( "logl" ) ;
extern double __builtin_log ( double __x ) asm ( "log" ) ;
extern float __builtin_logf ( float __x ) asm ( "logf" ) ;

extern long double __builtin_modfl ( long double __x , long double * __iptr ) asm ( "modfl" ) ;
extern double __builtin_modf ( double __x , double * __iptr ) asm ( "modf" ) ;
extern float __builtin_modff ( float __x , float * __iptr ) asm ( "modff" ) ;

extern double __builtin_nearbyint ( double x ) ;
extern float __builtin_nearbyintf ( float x ) ;
extern long double __builtin_nearbyintl ( long double x ) ;

extern double __builtin_nexttoward ( double x , double y ) ;
extern float __builtin_nexttowardf ( float x , float y ) ;
extern long double __builtin_nexttowardl ( long double x , long double y ) ;

extern double __builtin_nextafter ( double x , double y ) ;
extern float __builtin_nextafterf ( float x , float y ) ;
extern long double __builtin_nextafterl ( long double x , long double y ) ;

extern double __builtin_remainder ( double x , double y ) ;
extern float __builtin_remainderf ( float x , float y ) ;
extern long double __builtin_remainderl ( long double x , long double y ) ;

extern double __builtin_remquo ( double x , double y , int * c ) ;
extern float __builtin_remquof ( float x , float y , int * c ) ;
extern long double __builtin_remquol ( long double x , long double y , int * c ) ;

extern long double __builtin_powl ( long double __x , long double __y ) asm ( "powl" ) ;
extern double __builtin_pow ( double __x , double __y ) asm ( "pow" ) ;
extern float __builtin_powf ( float __x , float __y ) asm ( "powf" ) ;

extern double __builtin_round ( double x ) ;
extern float __builtin_roundf ( float x ) ;
extern long double __builtin_roundl ( long double x ) ;

extern double __builtin_rint ( double x ) ;
extern float __builtin_rintf ( float x ) ;
extern long double __builtin_rintl ( long double x ) ;

extern double __builtin_scalb ( double m , double p ) ;
extern float __builtin_scalbf ( float m , float p ) ;
extern long double __builtin_scalbl ( long double m , long double p ) ;

extern double __builtin_scalbn ( double m , int p ) ;
extern float __builtin_scalbnf ( float m , int p ) ;
extern long double __builtin_scalbnl ( long double m , int p ) ;

extern double __builtin_scalbln ( double m , long p ) ;
extern float __builtin_scalblnf ( float m , long p ) ;
extern long double __builtin_scalblnl ( long double m , long p ) ;

extern long double __builtin_sqrtl ( long double __x ) asm ( "sqrtl" ) ;
extern double __builtin_sqrt ( double __x ) asm ( "sqrt" ) ;
extern float __builtin_sqrtf ( float __x ) asm ( "sqrtf" ) ;

extern double __builtin_tgamma ( double x ) ;
extern float __builtin_tgammaf ( float x ) ;
extern long double __builtin_tgammal ( long double x ) ;

extern double __builtin_trunc ( double x ) ;
extern float __builtin_truncf ( float x ) ;
extern long double __builtin_truncl ( long double x ) ;

extern double __builtin_cbrt ( double x ) ;
extern float __builtin_cbrtf ( float x ) ;
extern long double __builtin_cbrtl ( long double x ) ;

extern double __builtin_copysign ( double x , double y ) ;
extern float __builtin_copysignf ( float x , float y ) ;
extern long double __builtin_copysignl ( long double x , long double y ) ;

extern double __builtin_erf ( double x ) ;
extern float __builtin_erff ( float x ) ;
extern long double __builtin_erfl ( long double x ) ;
extern double __builtin_erfc ( double x ) ;
extern float __builtin_erfcf ( float x ) ;
extern long double __builtin_erfcl ( long double x ) ;

char * __builtin_stpncpy ( char * , const char * , __builtin_size_t ) asm ( "stpncpy" ) ;
char * __builtin_stpcpy ( char * , const char * ) asm ( "stpcpy" ) ;
char * __builtin_strcpy ( char * , const char * ) asm ( "strcpy" ) ;
char * __builtin_strncpy ( char * , const char * , __builtin_size_t ) asm ( "strncpy" ) ;
char * __builtin_strcat ( char * , const char * ) asm ( "strcat" ) ;
char * __builtin_strncat ( char * , const char * , __builtin_size_t ) asm ( "strncat" ) ;
int __builtin_strcmp ( const char * , const char * ) asm ( "strcmp" ) ;
int __builtin_strncmp ( const char * , const char * , __builtin_size_t ) asm ( "strncmp" ) ;
char * __builtin_strdup ( const char * ) asm ( "strdup" ) ;
char * __builtin_strndup ( const char * , __builtin_size_t ) asm ( "strndup" ) ;
char * __builtin_strchr ( const char * , int ) asm ( "strchr" ) ;
char * __builtin_strrchr ( const char * , int ) asm ( "strrchr" ) ;
__builtin_size_t __builtin_strcspn ( const char * , const char * ) asm ( "strcspn" ) ;
__builtin_size_t __builtin_strspn ( const char * , const char * ) asm ( "strspn" ) ;
char * __builtin_strpbrk ( const char * , const char * ) asm ( "strpbrk" ) ;
char * __builtin_strstr ( const char * , const char * ) asm ( "strstr" ) ;
__builtin_size_t __builtin_strlen ( const char * __s ) asm ( "strlen" ) ;
int __builtin_strcasecmp ( const char * , const char * ) asm ( "strcasecmp" ) ;
int __builtin_strncasecmp ( const char * , const char * , __builtin_size_t ) asm ( "strncasecmp" ) ;


extern int __builtin_printf ( const char * , ... ) asm ( "printf" ) ;
extern int __builtin_sprintf ( char * , const char * , ... ) asm ( "sprintf" ) ;
extern int __builtin_vprintf ( const char * , __sun_va_list ) asm ( "vprintf" ) ;
extern int __builtin_vsprintf ( char * , const char * , __sun_va_list ) asm ( "vsprintf" ) ;
extern int __builtin_snprintf ( char * , __builtin_size_t , const char * , ... ) asm ( "snprintf" ) ;
extern int __builtin_vsnprintf ( char * , __builtin_size_t , const char * , __sun_va_list ) asm ( "vsnprintf" ) ;
extern int __builtin_vasprintf ( char * * , const char * __f , __sun_va_list ) asm ( "vasprintf" ) ;
extern int __builtin_asprintf ( char * * , const char * , ... ) asm ( "asprintf" ) ;




extern int __builtin_scanf ( const char * , ... ) asm ( "scanf" ) ;
extern int __builtin_sscanf ( const char * , const char * , ... ) asm ( "sscanf" ) ;
extern int __builtin_vscanf ( const char * , __sun_va_list ) asm ( "vscanf" ) ;
extern int __builtin_vsscanf ( const char * , const char * , __sun_va_list ) asm ( "vsscanf" ) ;
#574
extern int __builtin_vfprintf ( void * , const char * , __sun_va_list ) asm ( "vfprintf" ) ;
extern int __builtin_fprintf ( void * , const char * , ... ) asm ( "fprintf" ) ;
extern int __builtin_fscanf ( void * , const char * , ... ) asm ( "fscanf" ) ;
extern int __builtin_vfscanf ( void * , const char * , __sun_va_list ) asm ( "vfscanf" ) ;

extern void * __builtin_alloca ( __builtin_size_t ) ;



extern void __builtin_abort ( void ) throw ( ) asm ( "abort" ) ;

extern "C" constexpr int __builtin_clz ( unsigned int ) ;
extern "C" constexpr int __builtin_clzl ( unsigned long ) ;
extern "C" constexpr int __builtin_clzll ( unsigned long long ) ;

extern "C" constexpr int __builtin_ctz ( unsigned int ) ;
extern "C" constexpr int __builtin_ctzl ( unsigned long ) ;
extern "C" constexpr int __builtin_ctzll ( unsigned long long ) ;

extern "C" constexpr int __builtin_popcount ( unsigned int ) ;
extern "C" constexpr int __builtin_popcountl ( unsigned long ) ;
extern "C" constexpr int __builtin_popcountll ( unsigned long long ) ;

extern "C" inline double __builtin_powi ( double , int ) ;
extern "C" inline float __builtin_powif ( float , int ) ;
extern "C" inline long double __builtin_powil ( long double , int ) ;

extern "C++" inline int __builtin_fpclassify ( int , int , int , int , int , float ) ;
extern "C++" inline int __builtin_fpclassify ( int , int , int , int , int , double ) ;
extern "C++" inline int __builtin_fpclassify ( int , int , int , int , int , long double ) ;
#613
extern "C++" template < typename T >
inline bool __builtin_atomic_compare_exchange_n ( void * , void * , T , bool , int , int ) ;
#621
}



typedef __sun_va_list __builtin_va_list ;
#633
extern "C" void __builtin_va_start ( __sun_va_list , ... ) ;
#1 "./boost/regex.hpp"
#1 "./boost/regex/config.hpp"
#1 "./boost/regex/user.hpp"
#1 "./boost/config.hpp"
#1 "./boost/config/user.hpp"
#1 "./boost/config/select_compiler_config.hpp"
#1 "./boost/config/compiler/sunpro_cc.hpp"
#1 "./boost/config/select_stdlib_config.hpp"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/cstddef"
#9
namespace std {
typedef decltype ( nullptr ) nullptr_t ;
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstddef"
#39
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/bits/c++config.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/c++config.h"
#184
namespace std
{
typedef unsigned long size_t ;
typedef long ptrdiff_t ;


typedef decltype ( nullptr ) nullptr_t ;

}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/os_defines.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/cpu_defines.h"
#1 "/usr/include/stddef.h"
#16
#pragma ident "@(#)stddef.h 1.18    04/09/28 SMI"
#1 "/usr/include/sys/isa_defs.h"
#8
#pragma ident "@(#)isa_defs.h   1.30    11/03/31 SMI"
#193
extern "C" {
#512
}
#1 "/usr/include/iso/stddef_iso.h"
#28
#pragma ident "@(#)stddef_iso.h 1.2 03/03/06 SMI"
#33
extern "C" {



namespace std {
#51
typedef long ptrdiff_t ;
#60
typedef unsigned long size_t ;
#67
}
#77
}
#26 "/usr/include/stddef.h"
using std :: ptrdiff_t ;
using std :: size_t ;



extern "C" {
#49
}
#1 "./boost/config/no_tr1/utility.hpp"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/utility"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_relops.h"
#67
namespace std
{
namespace rel_ops
{
#85
template < class _Tp >
inline bool
operator != ( const _Tp & __x , const _Tp & __y )
{ return ! ( __x == __y ) ; }
#98
template < class _Tp >
inline bool
operator > ( const _Tp & __x , const _Tp & __y )
{ return __y < __x ; }
#111
template < class _Tp >
inline bool
operator <= ( const _Tp & __x , const _Tp & __y )
{ return ! ( __y < __x ) ; }
#124
template < class _Tp >
inline bool
operator >= ( const _Tp & __x , const _Tp & __y )
{ return ! ( __x < __y ) ; }


}

}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/bits/stl_pair.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/move.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/concept_check.h"
#33
#pragma GCC system_header
#36 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/move.h"
namespace std
{
#45
template < typename _Tp >
inline _Tp *
__addressof ( _Tp & __r ) noexcept
{
return reinterpret_cast < _Tp * >
( & const_cast < char & > ( reinterpret_cast < const volatile char & > ( __r ) ) ) ;
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/type_traits"
#32
#pragma GCC system_header
#40
namespace std
{
#56
template < typename _Tp , _Tp __v >
struct integral_constant
{
static constexpr _Tp value = __v ;
typedef _Tp value_type ;
typedef integral_constant < _Tp , __v > type ;
constexpr operator value_type ( ) { return value ; }
} ;

template < typename _Tp , _Tp __v >
constexpr _Tp integral_constant < _Tp , __v > :: value ;


typedef integral_constant < bool , true > true_type ;


typedef integral_constant < bool , false > false_type ;



template < bool , typename , typename >
struct conditional ;

template < typename ... >
struct __or_ ;

template < >
struct __or_ < >
: public false_type
{ } ;

template < typename _B1 >
struct __or_ < _B1 >
: public _B1
{ } ;

template < typename _B1 , typename _B2 >
struct __or_ < _B1 , _B2 >
: public conditional < _B1 :: value , _B1 , _B2 > :: type
{ } ;

template < typename _B1 , typename _B2 , typename _B3 , typename ... _Bn >
struct __or_ < _B1 , _B2 , _B3 , _Bn ... >
: public conditional < _B1 :: value , _B1 , __or_ < _B2 , _B3 , _Bn ... >> :: type
{ } ;

template < typename ... >
struct __and_ ;

template < >
struct __and_ < >
: public true_type
{ } ;

template < typename _B1 >
struct __and_ < _B1 >
: public _B1
{ } ;

template < typename _B1 , typename _B2 >
struct __and_ < _B1 , _B2 >
: public conditional < _B1 :: value , _B2 , _B1 > :: type
{ } ;

template < typename _B1 , typename _B2 , typename _B3 , typename ... _Bn >
struct __and_ < _B1 , _B2 , _B3 , _Bn ... >
: public conditional < _B1 :: value , __and_ < _B2 , _B3 , _Bn ... > , _B1 > :: type
{ } ;

template < typename _Pp >
struct __not_
: public integral_constant < bool , ! _Pp :: value >
{ } ;

struct __sfinae_types
{
typedef char __one ;
typedef struct { char __arr [ 2 ] ; } __two ;
} ;
#141
template < typename _Tp >
struct __success_type
{ typedef _Tp type ; } ;

struct __failure_type
{ } ;



template < typename >
struct remove_cv ;

template < typename >
struct __is_void_helper
: public false_type { } ;

template < >
struct __is_void_helper < void >
: public true_type { } ;


template < typename _Tp >
struct is_void
: public integral_constant < bool , ( __is_void_helper < typename
remove_cv < _Tp > :: type > :: value ) >
{ } ;

template < typename >
struct __is_integral_helper
: public false_type { } ;

template < >
struct __is_integral_helper < bool >
: public true_type { } ;

template < >
struct __is_integral_helper < char >
: public true_type { } ;

template < >
struct __is_integral_helper < signed char >
: public true_type { } ;

template < >
struct __is_integral_helper < unsigned char >
: public true_type { } ;


template < >
struct __is_integral_helper < wchar_t >
: public true_type { } ;


template < >
struct __is_integral_helper < char16_t >
: public true_type { } ;

template < >
struct __is_integral_helper < char32_t >
: public true_type { } ;

template < >
struct __is_integral_helper < short >
: public true_type { } ;

template < >
struct __is_integral_helper < unsigned short >
: public true_type { } ;

template < >
struct __is_integral_helper < int >
: public true_type { } ;

template < >
struct __is_integral_helper < unsigned int >
: public true_type { } ;

template < >
struct __is_integral_helper < long >
: public true_type { } ;

template < >
struct __is_integral_helper < unsigned long >
: public true_type { } ;

template < >
struct __is_integral_helper < long long >
: public true_type { } ;

template < >
struct __is_integral_helper < unsigned long long >
: public true_type { } ;
#245
template < typename _Tp >
struct is_integral
: public integral_constant < bool , ( __is_integral_helper < typename
remove_cv < _Tp > :: type > :: value ) >
{ } ;

template < typename >
struct __is_floating_point_helper
: public false_type { } ;

template < >
struct __is_floating_point_helper < float >
: public true_type { } ;

template < >
struct __is_floating_point_helper < double >
: public true_type { } ;

template < >
struct __is_floating_point_helper < long double >
: public true_type { } ;
#274
template < typename _Tp >
struct is_floating_point
: public integral_constant < bool , ( __is_floating_point_helper < typename
remove_cv < _Tp > :: type > :: value ) >
{ } ;


template < typename >
struct is_array
: public false_type { } ;

template < typename _Tp , std :: size_t _Size >
struct is_array < _Tp [ _Size ] >
: public true_type { } ;

template < typename _Tp >
struct is_array < _Tp [ ] >
: public true_type { } ;

template < typename >
struct __is_pointer_helper
: public false_type { } ;

template < typename _Tp >
struct __is_pointer_helper < _Tp * >
: public true_type { } ;


template < typename _Tp >
struct is_pointer
: public integral_constant < bool , ( __is_pointer_helper < typename
remove_cv < _Tp > :: type > :: value ) >
{ } ;


template < typename >
struct is_lvalue_reference
: public false_type { } ;

template < typename _Tp >
struct is_lvalue_reference < _Tp & >
: public true_type { } ;


template < typename >
struct is_rvalue_reference
: public false_type { } ;

template < typename _Tp >
struct is_rvalue_reference < _Tp && >
: public true_type { } ;

template < typename >
struct is_function ;

template < typename >
struct __is_member_object_pointer_helper
: public false_type { } ;

template < typename _Tp , typename _Cp >
struct __is_member_object_pointer_helper < _Tp _Cp :: * >
: public integral_constant < bool , ! is_function < _Tp > :: value > { } ;


template < typename _Tp >
struct is_member_object_pointer
: public integral_constant < bool , ( __is_member_object_pointer_helper <
typename remove_cv < _Tp > :: type > :: value ) >
{ } ;

template < typename >
struct __is_member_function_pointer_helper
: public false_type { } ;

template < typename _Tp , typename _Cp >
struct __is_member_function_pointer_helper < _Tp _Cp :: * >
: public integral_constant < bool , is_function < _Tp > :: value > { } ;


template < typename _Tp >
struct is_member_function_pointer
: public integral_constant < bool , ( __is_member_function_pointer_helper <
typename remove_cv < _Tp > :: type > :: value ) >
{ } ;


template < typename _Tp >
struct is_enum
: public integral_constant < bool , __oracle_is_enum ( _Tp ) >
{ } ;


template < typename _Tp >
struct is_union
: public integral_constant < bool , __oracle_is_union ( _Tp ) >
{ } ;


template < typename _Tp >
struct is_class
: public integral_constant < bool , __oracle_is_class ( _Tp ) >
{ } ;


template < typename >
struct is_function
: public false_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ) >
: public true_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ... ) >
: public true_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ) const >
: public true_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ... ) const >
: public true_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ) volatile >
: public true_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ... ) volatile >
: public true_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ) const volatile >
: public true_type { } ;

template < typename _Res , typename ... _ArgTypes >
struct is_function < _Res ( _ArgTypes ... ... ) const volatile >
: public true_type { } ;

template < typename >
struct __is_nullptr_t_helper
: public false_type { } ;

template < >
struct __is_nullptr_t_helper < std :: nullptr_t >
: public true_type { } ;


template < typename _Tp >
struct __is_nullptr_t
: public integral_constant < bool , ( __is_nullptr_t_helper < typename
remove_cv < _Tp > :: type > :: value ) >
{ } ;




template < typename _Tp >
struct is_reference
: public __or_ < is_lvalue_reference < _Tp > ,
is_rvalue_reference < _Tp >> :: type
{ } ;


template < typename _Tp >
struct is_arithmetic
: public __or_ < is_integral < _Tp > , is_floating_point < _Tp >> :: type
{ } ;


template < typename _Tp >
struct is_fundamental
: public __or_ < is_arithmetic < _Tp > , is_void < _Tp > , __is_nullptr_t < _Tp >> :: type
{ } ;


template < typename _Tp >
struct is_object
: public __not_ < __or_ < is_function < _Tp > , is_reference < _Tp > ,
is_void < _Tp >> > :: type
{ } ;

template < typename >
struct is_member_pointer ;


template < typename _Tp >
struct is_scalar
: public __or_ < is_arithmetic < _Tp > , is_enum < _Tp > , is_pointer < _Tp > ,
is_member_pointer < _Tp > , __is_nullptr_t < _Tp >> :: type
{ } ;


template < typename _Tp >
struct is_compound
: public integral_constant < bool , ! is_fundamental < _Tp > :: value > { } ;

template < typename _Tp >
struct __is_member_pointer_helper
: public false_type { } ;

template < typename _Tp , typename _Cp >
struct __is_member_pointer_helper < _Tp _Cp :: * >
: public true_type { } ;


template < typename _Tp >
struct is_member_pointer
: public integral_constant < bool , ( __is_member_pointer_helper <
typename remove_cv < _Tp > :: type > :: value ) >
{ } ;




template < typename >
struct is_const
: public false_type { } ;

template < typename _Tp >
struct is_const < _Tp const >
: public true_type { } ;


template < typename >
struct is_volatile
: public false_type { } ;

template < typename _Tp >
struct is_volatile < _Tp volatile >
: public true_type { } ;


template < typename _Tp >
struct is_trivial
: public integral_constant < bool , __oracle_is_trivial ( _Tp ) >
{ } ;




template < typename _Tp >
struct is_standard_layout
: public integral_constant < bool , __oracle_is_standard_layout ( _Tp ) >
{ } ;



template < typename _Tp >
struct is_pod
: public integral_constant < bool , __oracle_is_pod ( _Tp ) >
{ } ;


template < typename _Tp >
struct is_literal_type
: public integral_constant < bool , __oracle_is_literal_type ( _Tp ) >
{ } ;


template < typename _Tp >
struct is_empty
: public integral_constant < bool , __oracle_is_empty ( _Tp ) >
{ } ;


template < typename _Tp >
struct is_polymorphic
: public integral_constant < bool , __oracle_is_polymorphic ( _Tp ) >
{ } ;


template < typename _Tp >
struct is_abstract
: public integral_constant < bool , __oracle_is_abstract ( _Tp ) >
{ } ;

template < typename _Tp ,
bool = is_integral < _Tp > :: value ,
bool = is_floating_point < _Tp > :: value >
struct __is_signed_helper
: public false_type { } ;

template < typename _Tp >
struct __is_signed_helper < _Tp , false , true >
: public true_type { } ;

template < typename _Tp >
struct __is_signed_helper < _Tp , true , false >
: public integral_constant < bool , static_cast < bool > ( _Tp ( - 1 ) < _Tp ( 0 ) ) >
{ } ;


template < typename _Tp >
struct is_signed
: public integral_constant < bool , __is_signed_helper < _Tp > :: value >
{ } ;


template < typename _Tp >
struct is_unsigned
: public __and_ < is_arithmetic < _Tp > , __not_ < is_signed < _Tp >> > :: type
{ } ;




template < typename >
struct add_rvalue_reference ;





template < typename _Tp >
typename add_rvalue_reference < _Tp > :: type declval ( ) noexcept ;

template < typename , unsigned = 0 >
struct extent ;

template < typename >
struct remove_all_extents ;

template < typename _Tp >
struct __is_array_known_bounds
: public integral_constant < bool , ( extent < _Tp > :: value > 0 ) >
{ } ;

template < typename _Tp >
struct __is_array_unknown_bounds
: public __and_ < is_array < _Tp > , __not_ < extent < _Tp >> > :: type
{ } ;
#613
struct __do_is_destructible_impl
{
template < typename _Tp , typename = decltype ( declval < _Tp & > ( ) . ~ _Tp ( ) ) >
static true_type __test ( int ) ;

template < typename >
static false_type __test ( ... ) ;
} ;

template < typename _Tp >
struct __is_destructible_impl
: public __do_is_destructible_impl
{
typedef decltype ( __test < _Tp > ( 0 ) ) type ;
} ;

template < typename _Tp ,
bool = __or_ < is_void < _Tp > ,
__is_array_unknown_bounds < _Tp > ,
is_function < _Tp >> :: value ,
bool = __or_ < is_reference < _Tp > , is_scalar < _Tp >> :: value >
struct __is_destructible_safe ;

template < typename _Tp >
struct __is_destructible_safe < _Tp , false , false >
: public __is_destructible_impl < typename
remove_all_extents < _Tp > :: type > :: type
{ } ;

template < typename _Tp >
struct __is_destructible_safe < _Tp , true , false >
: public false_type { } ;

template < typename _Tp >
struct __is_destructible_safe < _Tp , false , true >
: public true_type { } ;


template < typename _Tp >
struct is_destructible
: public integral_constant < bool , ( __is_destructible_safe < _Tp > :: value ) >
{ } ;





struct __do_is_nt_destructible_impl
{
template < typename _Tp >
static integral_constant < bool , noexcept ( declval < _Tp & > ( ) . ~ _Tp ( ) ) >
__test ( int ) ;

template < typename >
static false_type __test ( ... ) ;
} ;

template < typename _Tp >
struct __is_nt_destructible_impl
: public __do_is_nt_destructible_impl
{
typedef decltype ( __test < _Tp > ( 0 ) ) type ;
} ;

template < typename _Tp ,
bool = __or_ < is_void < _Tp > ,
__is_array_unknown_bounds < _Tp > ,
is_function < _Tp >> :: value ,
bool = __or_ < is_reference < _Tp > , is_scalar < _Tp >> :: value >
struct __is_nt_destructible_safe ;

template < typename _Tp >
struct __is_nt_destructible_safe < _Tp , false , false >
: public __is_nt_destructible_impl < typename
remove_all_extents < _Tp > :: type > :: type
{ } ;

template < typename _Tp >
struct __is_nt_destructible_safe < _Tp , true , false >
: public false_type { } ;

template < typename _Tp >
struct __is_nt_destructible_safe < _Tp , false , true >
: public true_type { } ;


template < typename _Tp >
struct is_nothrow_destructible
: public integral_constant < bool , ( __is_nt_destructible_safe < _Tp > :: value ) >
{ } ;

struct __do_is_default_constructible_impl
{
template < typename _Tp , typename = decltype ( _Tp ( ) ) >
static true_type __test ( int ) ;

template < typename >
static false_type __test ( ... ) ;
} ;

template < typename _Tp >
struct __is_default_constructible_impl
: public __do_is_default_constructible_impl
{
typedef decltype ( __test < _Tp > ( 0 ) ) type ;
} ;

template < typename _Tp >
struct __is_default_constructible_atom
: public __and_ < __not_ < is_void < _Tp >> ,
__is_default_constructible_impl < _Tp >> :: type
{ } ;

template < typename _Tp , bool = is_array < _Tp > :: value >
struct __is_default_constructible_safe ;
#734
template < typename _Tp >
struct __is_default_constructible_safe < _Tp , true >
: public __and_ < __is_array_known_bounds < _Tp > ,
__is_default_constructible_atom < typename
remove_all_extents < _Tp > :: type >> :: type
{ } ;

template < typename _Tp >
struct __is_default_constructible_safe < _Tp , false >
: public __is_default_constructible_atom < _Tp > :: type
{ } ;


template < typename _Tp >
struct is_default_constructible
: public integral_constant < bool , ( __is_default_constructible_safe <
_Tp > :: value ) >
{ } ;
#765
struct __do_is_static_castable_impl
{
template < typename _From , typename _To , typename
= decltype ( static_cast < _To > ( declval < _From > ( ) ) ) >
static true_type __test ( int ) ;

template < typename , typename >
static false_type __test ( ... ) ;
} ;

template < typename _From , typename _To >
struct __is_static_castable_impl
: public __do_is_static_castable_impl
{
typedef decltype ( __test < _From , _To > ( 0 ) ) type ;
} ;

template < typename _From , typename _To >
struct __is_static_castable_safe
: public __is_static_castable_impl < _From , _To > :: type
{ } ;


template < typename _From , typename _To >
struct __is_static_castable
: public integral_constant < bool , ( __is_static_castable_safe <
_From , _To > :: value ) >
{ } ;
#799
struct __do_is_direct_constructible_impl
{
template < typename _Tp , typename _Arg , typename
= decltype ( :: new _Tp ( declval < _Arg > ( ) ) ) >
static true_type __test ( int ) ;

template < typename , typename >
static false_type __test ( ... ) ;
} ;

template < typename _Tp , typename _Arg >
struct __is_direct_constructible_impl
: public __do_is_direct_constructible_impl
{
typedef decltype ( __test < _Tp , _Arg > ( 0 ) ) type ;
} ;

template < typename _Tp , typename _Arg >
struct __is_direct_constructible_new_safe
: public __and_ < is_destructible < _Tp > ,
__is_direct_constructible_impl < _Tp , _Arg >> :: type
{ } ;

template < typename , typename >
struct is_same ;

template < typename , typename >
struct is_base_of ;

template < typename >
struct remove_reference ;

template < typename _From , typename _To , bool
= __not_ < __or_ < is_void < _From > ,
is_function < _From >> > :: value >
struct __is_base_to_derived_ref ;



template < typename _From , typename _To >
struct __is_base_to_derived_ref < _From , _To , true >
{
typedef typename remove_cv < typename remove_reference < _From
> :: type > :: type __src_t ;
typedef typename remove_cv < typename remove_reference < _To
> :: type > :: type __dst_t ;
typedef __and_ < __not_ < is_same < __src_t , __dst_t >> ,
is_base_of < __src_t , __dst_t >> type ;
static constexpr bool value = type :: value ;
} ;

template < typename _From , typename _To >
struct __is_base_to_derived_ref < _From , _To , false >
: public false_type
{ } ;

template < typename _From , typename _To , bool
= __and_ < is_lvalue_reference < _From > ,
is_rvalue_reference < _To >> :: value >
struct __is_lvalue_to_rvalue_ref ;



template < typename _From , typename _To >
struct __is_lvalue_to_rvalue_ref < _From , _To , true >
{
typedef typename remove_cv < typename remove_reference <
_From > :: type > :: type __src_t ;
typedef typename remove_cv < typename remove_reference <
_To > :: type > :: type __dst_t ;
typedef __and_ < __not_ < is_function < __src_t >> ,
__or_ < is_same < __src_t , __dst_t > ,
is_base_of < __dst_t , __src_t >> > type ;
static constexpr bool value = type :: value ;
} ;

template < typename _From , typename _To >
struct __is_lvalue_to_rvalue_ref < _From , _To , false >
: public false_type
{ } ;
#886
template < typename _Tp , typename _Arg >
struct __is_direct_constructible_ref_cast
: public __and_ < __is_static_castable < _Arg , _Tp > ,
__not_ < __or_ < __is_base_to_derived_ref < _Arg , _Tp > ,
__is_lvalue_to_rvalue_ref < _Arg , _Tp >
>> > :: type
{ } ;

template < typename _Tp , typename _Arg >
struct __is_direct_constructible_new
: public conditional < is_reference < _Tp > :: value ,
__is_direct_constructible_ref_cast < _Tp , _Arg > ,
__is_direct_constructible_new_safe < _Tp , _Arg >
> :: type
{ } ;

template < typename _Tp , typename _Arg >
struct __is_direct_constructible
: public integral_constant < bool , ( __is_direct_constructible_new <
_Tp , _Arg > :: value ) >
{ } ;
#913
struct __do_is_nary_constructible_impl
{
template < typename _Tp , typename ... _Args , typename
= decltype ( _Tp ( declval < _Args > ( ) ... ) ) >
static true_type __test ( int ) ;

template < typename , typename ... >
static false_type __test ( ... ) ;
} ;

template < typename _Tp , typename ... _Args >
struct __is_nary_constructible_impl
: public __do_is_nary_constructible_impl
{
typedef decltype ( __test < _Tp , _Args ... > ( 0 ) ) type ;
} ;

template < typename _Tp , typename ... _Args >
struct __is_nary_constructible
: public __is_nary_constructible_impl < _Tp , _Args ... > :: type
{
static_assert ( sizeof ... ( _Args ) > 1 ,
"Only useful for > 1 arguments" ) ;
} ;

template < typename _Tp , typename ... _Args >
struct __is_constructible_impl
: public __is_nary_constructible < _Tp , _Args ... >
{ } ;

template < typename _Tp , typename _Arg >
struct __is_constructible_impl < _Tp , _Arg >
: public __is_direct_constructible < _Tp , _Arg >
{ } ;

template < typename _Tp >
struct __is_constructible_impl < _Tp >
: public is_default_constructible < _Tp >
{ } ;


template < typename _Tp , typename ... _Args >
struct is_constructible
: public integral_constant < bool , ( __is_constructible_impl < _Tp ,
_Args ... > :: value ) >
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_copy_constructible_impl ;

template < typename _Tp >
struct __is_copy_constructible_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_copy_constructible_impl < _Tp , false >
: public is_constructible < _Tp , const _Tp & >
{ } ;


template < typename _Tp >
struct is_copy_constructible
: public __is_copy_constructible_impl < _Tp >
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_move_constructible_impl ;

template < typename _Tp >
struct __is_move_constructible_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_move_constructible_impl < _Tp , false >
: public is_constructible < _Tp , _Tp && >
{ } ;


template < typename _Tp >
struct is_move_constructible
: public __is_move_constructible_impl < _Tp >
{ } ;

template < typename _Tp >
struct __is_nt_default_constructible_atom
: public integral_constant < bool , noexcept ( _Tp ( ) ) >
{ } ;

template < typename _Tp , bool = is_array < _Tp > :: value >
struct __is_nt_default_constructible_impl ;

template < typename _Tp >
struct __is_nt_default_constructible_impl < _Tp , true >
: public __and_ < __is_array_known_bounds < _Tp > ,
__is_nt_default_constructible_atom < typename
remove_all_extents < _Tp > :: type >> :: type
{ } ;

template < typename _Tp >
struct __is_nt_default_constructible_impl < _Tp , false >
: public __is_nt_default_constructible_atom < _Tp >
{ } ;


template < typename _Tp >
struct is_nothrow_default_constructible
: public __and_ < is_default_constructible < _Tp > ,
__is_nt_default_constructible_impl < _Tp >> :: type
{ } ;

template < typename _Tp , typename ... _Args >
struct __is_nt_constructible_impl
: public integral_constant < bool , noexcept ( _Tp ( declval < _Args > ( ) ... ) ) >
{ } ;

template < typename _Tp , typename _Arg >
struct __is_nt_constructible_impl < _Tp , _Arg >
: public integral_constant < bool ,
noexcept ( static_cast < _Tp > ( declval < _Arg > ( ) ) ) >
{ } ;

template < typename _Tp >
struct __is_nt_constructible_impl < _Tp >
: public is_nothrow_default_constructible < _Tp >
{ } ;


template < typename _Tp , typename ... _Args >
struct is_nothrow_constructible
: public __and_ < is_constructible < _Tp , _Args ... > ,
__is_nt_constructible_impl < _Tp , _Args ... >> :: type
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_nothrow_copy_constructible_impl ;

template < typename _Tp >
struct __is_nothrow_copy_constructible_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_nothrow_copy_constructible_impl < _Tp , false >
: public is_nothrow_constructible < _Tp , const _Tp & >
{ } ;


template < typename _Tp >
struct is_nothrow_copy_constructible
: public __is_nothrow_copy_constructible_impl < _Tp >
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_nothrow_move_constructible_impl ;

template < typename _Tp >
struct __is_nothrow_move_constructible_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_nothrow_move_constructible_impl < _Tp , false >
: public is_nothrow_constructible < _Tp , _Tp && >
{ } ;


template < typename _Tp >
struct is_nothrow_move_constructible
: public __is_nothrow_move_constructible_impl < _Tp >
{ } ;

template < typename _Tp , typename _Up >
class __is_assignable_helper
: public __sfinae_types
{
template < typename _Tp1 , typename _Up1 >
static decltype ( declval < _Tp1 > ( ) = declval < _Up1 > ( ) , __one ( ) )
__test ( int ) ;

template < typename , typename >
static __two __test ( ... ) ;

public :
static constexpr bool value = sizeof ( __test < _Tp , _Up > ( 0 ) ) == 1 ;
} ;


template < typename _Tp , typename _Up >
struct is_assignable
: public integral_constant < bool ,
__is_assignable_helper < _Tp , _Up > :: value >
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_copy_assignable_impl ;

template < typename _Tp >
struct __is_copy_assignable_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_copy_assignable_impl < _Tp , false >
: public is_assignable < _Tp & , const _Tp & >
{ } ;


template < typename _Tp >
struct is_copy_assignable
: public __is_copy_assignable_impl < _Tp >
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_move_assignable_impl ;

template < typename _Tp >
struct __is_move_assignable_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_move_assignable_impl < _Tp , false >
: public is_assignable < _Tp & , _Tp && >
{ } ;


template < typename _Tp >
struct is_move_assignable
: public __is_move_assignable_impl < _Tp >
{ } ;

template < typename _Tp , typename _Up >
struct __is_nt_assignable_impl
: public integral_constant < bool , noexcept ( declval < _Tp > ( ) = declval < _Up > ( ) ) >
{ } ;


template < typename _Tp , typename _Up >
struct is_nothrow_assignable
: public __and_ < is_assignable < _Tp , _Up > ,
__is_nt_assignable_impl < _Tp , _Up >> :: type
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_nt_copy_assignable_impl ;

template < typename _Tp >
struct __is_nt_copy_assignable_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_nt_copy_assignable_impl < _Tp , false >
: public is_nothrow_assignable < _Tp & , const _Tp & >
{ } ;


template < typename _Tp >
struct is_nothrow_copy_assignable
: public __is_nt_copy_assignable_impl < _Tp >
{ } ;

template < typename _Tp , bool = is_void < _Tp > :: value >
struct __is_nt_move_assignable_impl ;

template < typename _Tp >
struct __is_nt_move_assignable_impl < _Tp , true >
: public false_type { } ;

template < typename _Tp >
struct __is_nt_move_assignable_impl < _Tp , false >
: public is_nothrow_assignable < _Tp & , _Tp && >
{ } ;


template < typename _Tp >
struct is_nothrow_move_assignable
: public __is_nt_move_assignable_impl < _Tp >
{ } ;
#1203
template < typename _Tp >
struct is_trivially_destructible
: public __and_ < is_destructible < _Tp > , integral_constant < bool ,
__oracle_has_trivial_destructor ( _Tp ) >> :: type
{ } ;


template < typename _Tp >
struct has_trivial_default_constructor
: public integral_constant < bool , __oracle_has_trivial_constructor ( _Tp ) >
{ } ;


template < typename _Tp >
struct has_trivial_copy_constructor
: public integral_constant < bool , __oracle_has_trivial_copy ( _Tp ) >
{ } ;


template < typename _Tp >
struct has_trivial_copy_assign
: public integral_constant < bool , __oracle_has_trivial_assign ( _Tp ) >
{ } ;


template < typename _Tp >
struct has_virtual_destructor
: public integral_constant < bool , __oracle_has_virtual_destructor ( _Tp ) >
{ } ;





template < typename _Tp >
struct alignment_of
: public integral_constant < std :: size_t , __alignof ( _Tp ) > { } ;


template < typename >
struct rank
: public integral_constant < std :: size_t , 0 > { } ;

template < typename _Tp , std :: size_t _Size >
struct rank < _Tp [ _Size ] >
: public integral_constant < std :: size_t , 1 + rank < _Tp > :: value > { } ;

template < typename _Tp >
struct rank < _Tp [ ] >
: public integral_constant < std :: size_t , 1 + rank < _Tp > :: value > { } ;


template < typename , unsigned _Uint >
struct extent
: public integral_constant < std :: size_t , 0 > { } ;

template < typename _Tp , unsigned _Uint , std :: size_t _Size >
struct extent < _Tp [ _Size ] , _Uint >
: public integral_constant < std :: size_t ,
_Uint == 0 ? _Size : extent < _Tp ,
_Uint - 1 > :: value >
{ } ;

template < typename _Tp , unsigned _Uint >
struct extent < _Tp [ ] , _Uint >
: public integral_constant < std :: size_t ,
_Uint == 0 ? 0 : extent < _Tp ,
_Uint - 1 > :: value >
{ } ;





template < typename , typename >
struct is_same
: public false_type { } ;

template < typename _Tp >
struct is_same < _Tp , _Tp >
: public true_type { } ;


template < typename _Base , typename _Derived >
struct is_base_of
: public integral_constant < bool , __oracle_is_base_of ( _Base , _Derived ) >
{ } ;

template < typename _From , typename _To ,
bool = __or_ < is_void < _From > , is_function < _To > ,
is_array < _To >> :: value >
struct __is_convertible_helper
{ static constexpr bool value = is_void < _To > :: value ; } ;

template < typename _From , typename _To >
class __is_convertible_helper < _From , _To , false >
: public __sfinae_types
{
template < typename _To1 >
static void __test_aux ( _To1 ) ;

template < typename _From1 , typename _To1 >
static decltype ( __test_aux < _To1 > ( std :: declval < _From1 > ( ) ) , __one ( ) )
__test ( int ) ;

template < typename , typename >
static __two __test ( ... ) ;

public :
static constexpr bool value = sizeof ( __test < _From , _To > ( 0 ) ) == 1 ;
} ;


template < typename _From , typename _To >
struct is_convertible
: public integral_constant < bool ,
__is_convertible_helper < _From , _To > :: value >
{ } ;





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

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


template < typename _Tp >
struct remove_volatile
{ typedef _Tp type ; } ;

template < typename _Tp >
struct remove_volatile < _Tp volatile >
{ typedef _Tp type ; } ;


template < typename _Tp >
struct remove_cv
{
typedef typename
remove_const < typename remove_volatile < _Tp > :: type > :: type type ;
} ;


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


template < typename _Tp >
struct add_volatile
{ typedef _Tp volatile type ; } ;


template < typename _Tp >
struct add_cv
{
typedef typename
add_const < typename add_volatile < _Tp > :: type > :: type type ;
} ;





template < typename _Tp >
struct remove_reference
{ typedef _Tp type ; } ;

template < typename _Tp >
struct remove_reference < _Tp & >
{ typedef _Tp type ; } ;

template < typename _Tp >
struct remove_reference < _Tp && >
{ typedef _Tp type ; } ;

template < typename _Tp ,
bool = __and_ < __not_ < is_reference < _Tp >> ,
__not_ < is_void < _Tp >> > :: value ,
bool = is_rvalue_reference < _Tp > :: value >
struct __add_lvalue_reference_helper
{ typedef _Tp type ; } ;

template < typename _Tp >
struct __add_lvalue_reference_helper < _Tp , true , false >
{ typedef _Tp & type ; } ;

template < typename _Tp >
struct __add_lvalue_reference_helper < _Tp , false , true >
{ typedef typename remove_reference < _Tp > :: type & type ; } ;


template < typename _Tp >
struct add_lvalue_reference
: public __add_lvalue_reference_helper < _Tp >
{ } ;

template < typename _Tp ,
bool = __and_ < __not_ < is_reference < _Tp >> ,
__not_ < is_void < _Tp >> > :: value >
struct __add_rvalue_reference_helper
{ typedef _Tp type ; } ;

template < typename _Tp >
struct __add_rvalue_reference_helper < _Tp , true >
{ typedef _Tp && type ; } ;


template < typename _Tp >
struct add_rvalue_reference
: public __add_rvalue_reference_helper < _Tp >
{ } ;





template < typename _Unqualified , bool _IsConst , bool _IsVol >
struct __cv_selector ;

template < typename _Unqualified >
struct __cv_selector < _Unqualified , false , false >
{ typedef _Unqualified __type ; } ;

template < typename _Unqualified >
struct __cv_selector < _Unqualified , false , true >
{ typedef volatile _Unqualified __type ; } ;

template < typename _Unqualified >
struct __cv_selector < _Unqualified , true , false >
{ typedef const _Unqualified __type ; } ;

template < typename _Unqualified >
struct __cv_selector < _Unqualified , true , true >
{ typedef const volatile _Unqualified __type ; } ;

template < typename _Qualified , typename _Unqualified ,
bool _IsConst = is_const < _Qualified > :: value ,
bool _IsVol = is_volatile < _Qualified > :: value >
class __match_cv_qualifiers
{
typedef __cv_selector < _Unqualified , _IsConst , _IsVol > __match ;

public :
typedef typename __match :: __type __type ;
} ;


template < typename _Tp >
struct __make_unsigned
{ typedef _Tp __type ; } ;

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

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

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

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

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

template < >
struct __make_unsigned < long long >
{ typedef unsigned long long __type ; } ;
#1492
template < typename _Tp ,
bool _IsInt = is_integral < _Tp > :: value ,
bool _IsEnum = is_enum < _Tp > :: value >
class __make_unsigned_selector ;

template < typename _Tp >
class __make_unsigned_selector < _Tp , true , false >
{
typedef __make_unsigned < typename remove_cv < _Tp > :: type > __unsignedt ;
typedef typename __unsignedt :: __type __unsigned_type ;
typedef __match_cv_qualifiers < _Tp , __unsigned_type > __cv_unsigned ;

public :
typedef typename __cv_unsigned :: __type __type ;
} ;

template < typename _Tp >
class __make_unsigned_selector < _Tp , false , true >
{

typedef unsigned char __smallest ;
static const bool __b0 = sizeof ( _Tp ) <= sizeof ( __smallest ) ;
static const bool __b1 = sizeof ( _Tp ) <= sizeof ( unsigned short ) ;
static const bool __b2 = sizeof ( _Tp ) <= sizeof ( unsigned int ) ;
typedef conditional < __b2 , unsigned int , unsigned long > __cond2 ;
typedef typename __cond2 :: type __cond2_type ;
typedef conditional < __b1 , unsigned short , __cond2_type > __cond1 ;
typedef typename __cond1 :: type __cond1_type ;

public :
typedef typename conditional < __b0 , __smallest , __cond1_type > :: type __type ;
} ;





template < typename _Tp >
struct make_unsigned
{ typedef typename __make_unsigned_selector < _Tp > :: __type type ; } ;


template < >
struct make_unsigned < bool > ;



template < typename _Tp >
struct __make_signed
{ typedef _Tp __type ; } ;

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

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

template < >
struct __make_signed < unsigned short >
{ typedef signed short __type ; } ;

template < >
struct __make_signed < unsigned int >
{ typedef signed int __type ; } ;

template < >
struct __make_signed < unsigned long >
{ typedef signed long __type ; } ;

template < >
struct __make_signed < unsigned long long >
{ typedef signed long long __type ; } ;
#1574
template < typename _Tp ,
bool _IsInt = is_integral < _Tp > :: value ,
bool _IsEnum = is_enum < _Tp > :: value >
class __make_signed_selector ;

template < typename _Tp >
class __make_signed_selector < _Tp , true , false >
{
typedef __make_signed < typename remove_cv < _Tp > :: type > __signedt ;
typedef typename __signedt :: __type __signed_type ;
typedef __match_cv_qualifiers < _Tp , __signed_type > __cv_signed ;

public :
typedef typename __cv_signed :: __type __type ;
} ;

template < typename _Tp >
class __make_signed_selector < _Tp , false , true >
{

typedef signed char __smallest ;
static const bool __b0 = sizeof ( _Tp ) <= sizeof ( __smallest ) ;
static const bool __b1 = sizeof ( _Tp ) <= sizeof ( signed short ) ;
static const bool __b2 = sizeof ( _Tp ) <= sizeof ( signed int ) ;
typedef conditional < __b2 , signed int , signed long > __cond2 ;
typedef typename __cond2 :: type __cond2_type ;
typedef conditional < __b1 , signed short , __cond2_type > __cond1 ;
typedef typename __cond1 :: type __cond1_type ;

public :
typedef typename conditional < __b0 , __smallest , __cond1_type > :: type __type ;
} ;





template < typename _Tp >
struct make_signed
{ typedef typename __make_signed_selector < _Tp > :: __type type ; } ;


template < >
struct make_signed < bool > ;





template < typename _Tp >
struct remove_extent
{ typedef _Tp type ; } ;

template < typename _Tp , std :: size_t _Size >
struct remove_extent < _Tp [ _Size ] >
{ typedef _Tp type ; } ;

template < typename _Tp >
struct remove_extent < _Tp [ ] >
{ typedef _Tp type ; } ;


template < typename _Tp >
struct remove_all_extents
{ typedef _Tp type ; } ;

template < typename _Tp , std :: size_t _Size >
struct remove_all_extents < _Tp [ _Size ] >
{ typedef typename remove_all_extents < _Tp > :: type type ; } ;

template < typename _Tp >
struct remove_all_extents < _Tp [ ] >
{ typedef typename remove_all_extents < _Tp > :: type type ; } ;




template < typename _Tp , typename >
struct __remove_pointer_helper
{ typedef _Tp type ; } ;

template < typename _Tp , typename _Up >
struct __remove_pointer_helper < _Tp , _Up * >
{ typedef _Up type ; } ;


template < typename _Tp >
struct remove_pointer
: public __remove_pointer_helper < _Tp , typename remove_cv < _Tp > :: type >
{ } ;


template < typename _Tp >
struct add_pointer
{ typedef typename remove_reference < _Tp > :: type * type ; } ;


template < std :: size_t _Len >
struct __aligned_storage_msa
{
union __type
{
unsigned char __data [ _Len ] ;
struct __attribute__ ( ( __aligned__ ) ) { } __align ;
} ;
} ;
#1691
template < std :: size_t _Len , std :: size_t _Align =
__alignof ( typename __aligned_storage_msa < _Len > :: __type ) >
struct aligned_storage
{
union type
{
unsigned char __data [ _Len ] ;
struct __attribute__ ( ( __aligned__ ( ( _Align ) ) ) ) { } __align ;
} ;
} ;




template < typename _Up ,
bool _IsArray = is_array < _Up > :: value ,
bool _IsFunction = is_function < _Up > :: value >
struct __decay_selector ;


template < typename _Up >
struct __decay_selector < _Up , false , false >
{ typedef typename remove_cv < _Up > :: type __type ; } ;

template < typename _Up >
struct __decay_selector < _Up , true , false >
{ typedef typename remove_extent < _Up > :: type * __type ; } ;

template < typename _Up >
struct __decay_selector < _Up , false , true >
{ typedef typename add_pointer < _Up > :: type __type ; } ;


template < typename _Tp >
class decay
{
typedef typename remove_reference < _Tp > :: type __remove_type ;

public :
typedef typename __decay_selector < __remove_type > :: __type type ;
} ;

template < typename _Tp >
class reference_wrapper ;


template < typename _Tp >
struct __strip_reference_wrapper
{
typedef _Tp __type ;
} ;

template < typename _Tp >
struct __strip_reference_wrapper < reference_wrapper < _Tp > >
{
typedef _Tp & __type ;
} ;

template < typename _Tp >
struct __strip_reference_wrapper < const reference_wrapper < _Tp > >
{
typedef _Tp & __type ;
} ;

template < typename _Tp >
struct __decay_and_strip
{
typedef typename __strip_reference_wrapper <
typename decay < _Tp > :: type > :: __type __type ;
} ;




template < bool , typename _Tp = void >
struct enable_if
{ } ;


template < typename _Tp >
struct enable_if < true , _Tp >
{ typedef _Tp type ; } ;

template < typename ... _Cond >
using _Require = typename enable_if < __and_ < _Cond ... > :: value > :: type ;



template < bool _Cond , typename _Iftrue , typename _Iffalse >
struct conditional
{ typedef _Iftrue type ; } ;


template < typename _Iftrue , typename _Iffalse >
struct conditional < false , _Iftrue , _Iffalse >
{ typedef _Iffalse type ; } ;


template < typename ... _Tp >
struct common_type ;



struct __do_common_type_impl
{
template < typename _Tp , typename _Up >
static __success_type < typename decay < decltype
( true ? std :: declval < _Tp > ( )
: std :: declval < _Up > ( ) ) > :: type > _S_test ( int ) ;

template < typename , typename >
static __failure_type _S_test ( ... ) ;
} ;

template < typename _Tp , typename _Up >
struct __common_type_impl
: private __do_common_type_impl
{
typedef decltype ( _S_test < _Tp , _Up > ( 0 ) ) type ;
} ;

struct __do_member_type_wrapper
{
template < typename _Tp >
static __success_type < typename _Tp :: type > _S_test ( int ) ;

template < typename >
static __failure_type _S_test ( ... ) ;
} ;

template < typename _Tp >
struct __member_type_wrapper
: private __do_member_type_wrapper
{
typedef decltype ( _S_test < _Tp > ( 0 ) ) type ;
} ;

template < typename _CTp , typename ... _Args >
struct __expanded_common_type_wrapper
{
typedef common_type < typename _CTp :: type , _Args ... > type ;
} ;

template < typename ... _Args >
struct __expanded_common_type_wrapper < __failure_type , _Args ... >
{ typedef __failure_type type ; } ;

template < typename _Tp >
struct common_type < _Tp >
{ typedef typename decay < _Tp > :: type type ; } ;

template < typename _Tp , typename _Up >
struct common_type < _Tp , _Up >
: public __common_type_impl < _Tp , _Up > :: type
{ } ;

template < typename _Tp , typename _Up , typename ... _Vp >
struct common_type < _Tp , _Up , _Vp ... >
: public __expanded_common_type_wrapper < typename __member_type_wrapper <
common_type < _Tp , _Up >> :: type , _Vp ... > :: type
{ } ;


template < typename _Tp >
struct underlying_type
{
typedef __oracle_underlying_type ( _Tp ) type ;
} ;

template < typename _Tp >
struct __declval_protector
{
static const bool __stop = false ;
static typename add_rvalue_reference < _Tp > :: type __delegate ( ) ;
} ;

template < typename _Tp >
inline typename add_rvalue_reference < _Tp > :: type
declval ( ) noexcept
{
static_assert ( __declval_protector < _Tp > :: __stop ,
"declval() must not be used!" ) ;
return __declval_protector < _Tp > :: __delegate ( ) ;
}


template < typename _Signature >
class result_of ;




struct __result_of_memfun_ref_impl
{
template < typename _Fp , typename _Tp1 , typename ... _Args >
static __success_type < decltype (
( std :: declval < _Tp1 > ( ) .* std :: declval < _Fp > ( ) ) ( std :: declval < _Args > ( ) ... )
) > _S_test ( int ) ;

template < typename ... >
static __failure_type _S_test ( ... ) ;
} ;

template < typename _MemPtr , typename _Arg , typename ... _Args >
struct __result_of_memfun_ref
: private __result_of_memfun_ref_impl
{
typedef decltype ( _S_test < _MemPtr , _Arg , _Args ... > ( 0 ) ) type ;
} ;


struct __result_of_memfun_deref_impl
{
template < typename _Fp , typename _Tp1 , typename ... _Args >
static __success_type < decltype (
( ( * std :: declval < _Tp1 > ( ) ) .* std :: declval < _Fp > ( ) ) ( std :: declval < _Args > ( ) ... )
) > _S_test ( int ) ;

template < typename ... >
static __failure_type _S_test ( ... ) ;
} ;

template < typename _MemPtr , typename _Arg , typename ... _Args >
struct __result_of_memfun_deref
: private __result_of_memfun_deref_impl
{
typedef decltype ( _S_test < _MemPtr , _Arg , _Args ... > ( 0 ) ) type ;
} ;


struct __result_of_memobj_ref_impl
{
template < typename _Fp , typename _Tp1 >
static __success_type < decltype (
std :: declval < _Tp1 > ( ) .* std :: declval < _Fp > ( )
) > _S_test ( int ) ;

template < typename , typename >
static __failure_type _S_test ( ... ) ;
} ;

template < typename _MemPtr , typename _Arg >
struct __result_of_memobj_ref
: private __result_of_memobj_ref_impl
{
typedef decltype ( _S_test < _MemPtr , _Arg > ( 0 ) ) type ;
} ;


struct __result_of_memobj_deref_impl
{
template < typename _Fp , typename _Tp1 >
static __success_type < decltype (
( * std :: declval < _Tp1 > ( ) ) .* std :: declval < _Fp > ( )
) > _S_test ( int ) ;

template < typename , typename >
static __failure_type _S_test ( ... ) ;
} ;

template < typename _MemPtr , typename _Arg >
struct __result_of_memobj_deref
: private __result_of_memobj_deref_impl
{
typedef decltype ( _S_test < _MemPtr , _Arg > ( 0 ) ) type ;
} ;

template < typename _MemPtr , typename _Arg >
struct __result_of_memobj ;

template < typename _Res , typename _Class , typename _Arg >
struct __result_of_memobj < _Res _Class :: * , _Arg >
{
typedef typename remove_cv < typename remove_reference <
_Arg > :: type > :: type _Argval ;
typedef _Res _Class :: * _MemPtr ;
typedef typename conditional < __or_ < is_same < _Argval , _Class > ,
is_base_of < _Class , _Argval >> :: value ,
__result_of_memobj_ref < _MemPtr , _Arg > ,
__result_of_memobj_deref < _MemPtr , _Arg >
> :: type :: type type ;
} ;

template < typename _MemPtr , typename _Arg , typename ... _Args >
struct __result_of_memfun ;

template < typename _Res , typename _Class , typename _Arg , typename ... _Args >
struct __result_of_memfun < _Res _Class :: * , _Arg , _Args ... >
{
typedef typename remove_cv < typename remove_reference <
_Arg > :: type > :: type _Argval ;
typedef _Res _Class :: * _MemPtr ;
typedef typename conditional < __or_ < is_same < _Argval , _Class > ,
is_base_of < _Class , _Argval >> :: value ,
__result_of_memfun_ref < _MemPtr , _Arg , _Args ... > ,
__result_of_memfun_deref < _MemPtr , _Arg , _Args ... >
> :: type :: type type ;
} ;

template < bool , bool , typename _Functor , typename ... _ArgTypes >
struct __result_of_impl
{
typedef __failure_type type ;
} ;

template < typename _MemPtr , typename _Arg >
struct __result_of_impl < true , false , _MemPtr , _Arg >
: public __result_of_memobj < typename decay < _MemPtr > :: type , _Arg >
{ } ;

template < typename _MemPtr , typename _Arg , typename ... _Args >
struct __result_of_impl < false , true , _MemPtr , _Arg , _Args ... >
: public __result_of_memfun < typename decay < _MemPtr > :: type , _Arg , _Args ... >
{ } ;


struct __result_of_other_impl
{
template < typename _Fn , typename ... _Args >
static __success_type < decltype (
std :: declval < _Fn > ( ) ( std :: declval < _Args > ( ) ... )
) > _S_test ( int ) ;

template < typename ... >
static __failure_type _S_test ( ... ) ;
} ;

template < typename _Functor , typename ... _ArgTypes >
struct __result_of_impl < false , false , _Functor , _ArgTypes ... >
: private __result_of_other_impl
{
typedef decltype ( _S_test < _Functor , _ArgTypes ... > ( 0 ) ) type ;
} ;

template < typename _Functor , typename ... _ArgTypes >
struct result_of < _Functor ( _ArgTypes ... ) >
: public __result_of_impl <
is_member_object_pointer <
typename remove_reference < _Functor > :: type
> :: value ,
is_member_function_pointer <
typename remove_reference < _Functor > :: type
> :: value ,
_Functor , _ArgTypes ...
> :: type
{ } ;
#2070
}
#59 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/move.h"
namespace std
{
#74
template < typename _Tp >
constexpr _Tp &&
forward ( typename std :: remove_reference < _Tp > :: type & __t ) noexcept
{ return static_cast < _Tp && > ( __t ) ; }
#85
template < typename _Tp >
constexpr _Tp &&
forward ( typename std :: remove_reference < _Tp > :: type && __t ) noexcept
{
static_assert ( ! std :: is_lvalue_reference < _Tp > :: value , "template argument"
" substituting _Tp is an lvalue reference type" ) ;
return static_cast < _Tp && > ( __t ) ;
}
#99
template < typename _Tp >
constexpr typename std :: remove_reference < _Tp > :: type &&
move ( _Tp && __t ) noexcept
{ return static_cast < typename std :: remove_reference < _Tp > :: type && > ( __t ) ; }


template < typename _Tp >
struct __move_if_noexcept_cond
: public __and_ < __not_ < is_nothrow_move_constructible < _Tp >> ,
is_copy_constructible < _Tp >> :: type { } ;
#118
template < typename _Tp >
inline constexpr typename
conditional < __move_if_noexcept_cond < _Tp > :: value , const _Tp & , _Tp && > :: type
move_if_noexcept ( _Tp & __x ) noexcept
{ return std :: move ( __x ) ; }
#133
template < typename _Tp >
inline _Tp *
addressof ( _Tp & __r ) noexcept
{ return std :: __addressof ( __r ) ; }



}
#149
namespace std
{
#164
template < typename _Tp >
inline void
swap ( _Tp & __a , _Tp & __b )

noexcept ( __and_ < is_nothrow_move_constructible < _Tp > ,
is_nothrow_move_assignable < _Tp >> :: value )

{



_Tp __tmp = std :: move ( __a ) ;
__a = std :: move ( __b ) ;
__b = std :: move ( __tmp ) ;
}




template < typename _Tp , size_t _Nm >
inline void
swap ( _Tp ( & __a ) [ _Nm ] , _Tp ( & __b ) [ _Nm ] )

noexcept ( noexcept ( swap ( * __a , * __b ) ) )

{
for ( size_t __n = 0 ; __n < _Nm ; ++ __n )
swap ( __a [ __n ] , __b [ __n ] ) ;
}



}
#73 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/bits/stl_pair.h"
namespace std
{
#84
struct piecewise_construct_t { } ;


constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t ( ) ;


template < typename ... >
class tuple ;

template < std :: size_t ... >
struct _Index_tuple ;
#103
template < class _T1 , class _T2 >
struct pair
{
typedef _T1 first_type ;
typedef _T2 second_type ;

_T1 first ;
_T2 second ;





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


constexpr pair ( const _T1 & __a , const _T2 & __b )
: first ( __a ) , second ( __b ) { }
#129
template < class _U1 , class _U2 , class = typename
enable_if < __and_ < is_convertible < const _U1 & , _T1 > ,
is_convertible < const _U2 & , _T2 >> :: value > :: type >
constexpr pair ( const pair < _U1 , _U2 > & __p )
: first ( __p . first ) , second ( __p . second ) { }

constexpr pair ( const pair & ) = default ;
constexpr pair ( pair && ) = default ;


template < class _U1 , class = typename
enable_if < is_convertible < _U1 , _T1 > :: value > :: type >
constexpr pair ( _U1 && __x , const _T2 & __y )
: first ( std :: forward < _U1 > ( __x ) ) , second ( __y ) { }

template < class _U2 , class = typename
enable_if < is_convertible < _U2 , _T2 > :: value > :: type >
constexpr pair ( const _T1 & __x , _U2 && __y )
: first ( __x ) , second ( std :: forward < _U2 > ( __y ) ) { }

template < class _U1 , class _U2 , class = typename
enable_if < __and_ < is_convertible < _U1 , _T1 > ,
is_convertible < _U2 , _T2 >> :: value > :: type >
constexpr pair ( _U1 && __x , _U2 && __y )
: first ( std :: forward < _U1 > ( __x ) ) , second ( std :: forward < _U2 > ( __y ) ) { }

template < class _U1 , class _U2 , class = typename
enable_if < __and_ < is_convertible < _U1 , _T1 > ,
is_convertible < _U2 , _T2 >> :: value > :: type >
constexpr pair ( pair < _U1 , _U2 > && __p )
: first ( std :: forward < _U1 > ( __p . first ) ) ,
second ( std :: forward < _U2 > ( __p . second ) ) { }

template < typename ... _Args1 , typename ... _Args2 >
pair ( piecewise_construct_t , tuple < _Args1 ... > , tuple < _Args2 ... > ) ;

pair &
operator = ( const pair & __p )
{
first = __p . first ;
second = __p . second ;
return * this ;
}

pair &
operator = ( pair && __p )
noexcept ( __and_ < is_nothrow_move_assignable < _T1 > ,
is_nothrow_move_assignable < _T2 >> :: value )
{
first = std :: forward < first_type > ( __p . first ) ;
second = std :: forward < second_type > ( __p . second ) ;
return * this ;
}

template < class _U1 , class _U2 >
pair &
operator = ( const pair < _U1 , _U2 > & __p )
{
first = __p . first ;
second = __p . second ;
return * this ;
}

template < class _U1 , class _U2 >
pair &
operator = ( pair < _U1 , _U2 > && __p )
{
first = std :: forward < _U1 > ( __p . first ) ;
second = std :: forward < _U2 > ( __p . second ) ;
return * this ;
}

void
swap ( pair & __p )
noexcept ( noexcept ( std :: swap ( first , __p . first ) )
&& noexcept ( std :: swap ( second , __p . second ) ) )
{
using std :: swap ;
swap ( first , __p . first ) ;
swap ( second , __p . second ) ;
}

private :
template < typename ... _Args1 , std :: size_t ... _Indexes1 ,
typename ... _Args2 , std :: size_t ... _Indexes2 >
pair ( tuple < _Args1 ... > & , tuple < _Args2 ... > & ,
_Index_tuple < _Indexes1 ... > , _Index_tuple < _Indexes2 ... > ) ;

} ;


template < class _T1 , class _T2 >
inline constexpr 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 constexpr 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 constexpr bool
operator != ( const pair < _T1 , _T2 > & __x , const pair < _T1 , _T2 > & __y )
{ return ! ( __x == __y ) ; }


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


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


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





template < class _T1 , class _T2 >
inline void
swap ( pair < _T1 , _T2 > & __x , pair < _T1 , _T2 > & __y )
noexcept ( noexcept ( __x . swap ( __y ) ) )
{ __x . swap ( __y ) ; }
#281
template < class _T1 , class _T2 >
constexpr pair < typename __decay_and_strip < _T1 > :: __type ,
typename __decay_and_strip < _T2 > :: __type >
make_pair ( _T1 && __x , _T2 && __y )
{
typedef typename __decay_and_strip < _T1 > :: __type __ds_type1 ;
typedef typename __decay_and_strip < _T2 > :: __type __ds_type2 ;
typedef pair < __ds_type1 , __ds_type2 > __pair_type ;
return __pair_type ( std :: forward < _T1 > ( __x ) , std :: forward < _T2 > ( __y ) ) ;
}
#301
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/initializer_list"
#33
#pragma GCC system_header





#pragma GCC visibility push ( default )
#43
namespace std
{

template < class _E >
class initializer_list
{
public :
typedef _E value_type ;
typedef const _E & reference ;
typedef const _E & const_reference ;
typedef size_t size_type ;
typedef const _E * iterator ;
typedef const _E * const_iterator ;

private :
iterator _M_array ;
size_type _M_len ;


constexpr initializer_list ( const_iterator __a , size_type __l )
: _M_array ( __a ) , _M_len ( __l ) { }

public :
constexpr initializer_list ( ) noexcept
: _M_array ( 0 ) , _M_len ( 0 ) { }


constexpr size_type
size ( ) const noexcept { return _M_len ; }


constexpr const_iterator
begin ( ) const noexcept { return _M_array ; }


constexpr const_iterator
end ( ) const noexcept { return begin ( ) + size ( ) ; }
} ;
#87
template < class _Tp >
constexpr const _Tp *
begin ( initializer_list < _Tp > __ils ) noexcept
{ return __ils . begin ( ) ; }
#97
template < class _Tp >
constexpr const _Tp *
end ( initializer_list < _Tp > __ils ) noexcept
{ return __ils . end ( ) ; }
}

#pragma GCC visibility pop
#76 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/utility"
namespace std
{


template < class _Tp >
class tuple_size ;

template < std :: size_t _Int , class _Tp >
class tuple_element ;


template < class _Tp1 , class _Tp2 >
struct tuple_size < std :: pair < _Tp1 , _Tp2 >>
: public integral_constant < std :: size_t , 2 > { } ;

template < class _Tp1 , class _Tp2 >
struct tuple_element < 0 , std :: pair < _Tp1 , _Tp2 >>
{ typedef _Tp1 type ; } ;

template < class _Tp1 , class _Tp2 >
struct tuple_element < 1 , std :: pair < _Tp1 , _Tp2 >>
{ typedef _Tp2 type ; } ;

template < std :: size_t _Int >
struct __pair_get ;

template < >
struct __pair_get < 0 >
{
template < typename _Tp1 , typename _Tp2 >
static constexpr _Tp1 &
__get ( std :: pair < _Tp1 , _Tp2 > & __pair ) noexcept
{ return __pair . first ; }

template < typename _Tp1 , typename _Tp2 >
static constexpr _Tp1 &&
__move_get ( std :: pair < _Tp1 , _Tp2 > && __pair ) noexcept
{ return std :: forward < _Tp1 > ( __pair . first ) ; }

template < typename _Tp1 , typename _Tp2 >
static constexpr const _Tp1 &
__const_get ( const std :: pair < _Tp1 , _Tp2 > & __pair ) noexcept
{ return __pair . first ; }
} ;

template < >
struct __pair_get < 1 >
{
template < typename _Tp1 , typename _Tp2 >
static constexpr _Tp2 &
__get ( std :: pair < _Tp1 , _Tp2 > & __pair ) noexcept
{ return __pair . second ; }

template < typename _Tp1 , typename _Tp2 >
static constexpr _Tp2 &&
__move_get ( std :: pair < _Tp1 , _Tp2 > && __pair ) noexcept
{ return std :: forward < _Tp2 > ( __pair . second ) ; }

template < typename _Tp1 , typename _Tp2 >
static constexpr const _Tp2 &
__const_get ( const std :: pair < _Tp1 , _Tp2 > & __pair ) noexcept
{ return __pair . second ; }
} ;

template < std :: size_t _Int , class _Tp1 , class _Tp2 >
constexpr typename tuple_element < _Int , std :: pair < _Tp1 , _Tp2 >> :: type &
get ( std :: pair < _Tp1 , _Tp2 > & __in ) noexcept
{ return __pair_get < _Int > :: __get ( __in ) ; }

template < std :: size_t _Int , class _Tp1 , class _Tp2 >
constexpr typename tuple_element < _Int , std :: pair < _Tp1 , _Tp2 >> :: type &&
get ( std :: pair < _Tp1 , _Tp2 > && __in ) noexcept
{ return __pair_get < _Int > :: __move_get ( std :: move ( __in ) ) ; }

template < std :: size_t _Int , class _Tp1 , class _Tp2 >
constexpr const typename tuple_element < _Int , std :: pair < _Tp1 , _Tp2 >> :: type &
get ( const std :: pair < _Tp1 , _Tp2 > & __in ) noexcept
{ return __pair_get < _Int > :: __const_get ( __in ) ; }


}
#1 "./boost/config/stdlib/libstdcpp3.hpp"
#1 "/usr/include/unistd.h"
#16
#pragma ident "@(#)unistd.h 1.76    06/03/10 SMI"
#1 "/usr/include/sys/feature_tests.h"
#8
#pragma ident "@(#)feature_tests.h  1.26    11/04/12 SMI"
#1 "/usr/include/sys/ccompile.h"
#9
#pragma ident "@(#)ccompile.h   1.2 04/11/08 SMI"
#17
extern "C" {
#103
}
#14 "/usr/include/sys/feature_tests.h"
extern "C" {
#377
}
#1 "/usr/include/sys/types.h"
#15
#pragma ident "@(#)types.h  1.88    12/06/11 SMI"
#1 "/usr/include/sys/machtypes.h"
#9
#pragma ident "@(#)machtypes.h  1.11    04/09/28 SMI"
#1 "/usr/include/ia32/sys/machtypes.h"
#9
#pragma ident "@(#)machtypes.h  1.2 04/09/28 SMI"


extern "C" {
#25
typedef struct _label_t { long val [ 8 ] ; } label_t ;
#32
typedef unsigned char lock_t ;


}
#1 "/usr/include/sys/int_types.h"
#9
#pragma ident "@(#)int_types.h  1.10    04/09/28 SMI"
#37
extern "C" {
#54
typedef char int8_t ;





typedef short int16_t ;
typedef int int32_t ;


typedef long int64_t ;
#72
typedef unsigned char uint8_t ;
typedef unsigned short uint16_t ;
typedef unsigned int uint32_t ;

typedef unsigned long uint64_t ;
#88
typedef int64_t intmax_t ;
typedef uint64_t uintmax_t ;
#101
typedef long intptr_t ;
typedef unsigned long uintptr_t ;
#113
typedef char int_fast8_t ;





typedef int int_fast16_t ;
typedef int int_fast32_t ;

typedef long int_fast64_t ;
#129
typedef unsigned char uint_fast8_t ;
typedef unsigned int uint_fast16_t ;
typedef unsigned int uint_fast32_t ;

typedef unsigned long uint_fast64_t ;
#145
typedef char int_least8_t ;





typedef short int_least16_t ;
typedef int int_least32_t ;

typedef long int_least64_t ;
#161
typedef unsigned char uint_least8_t ;
typedef unsigned short uint_least16_t ;
typedef unsigned int uint_least32_t ;

typedef unsigned long uint_least64_t ;
#173
}
#43 "/usr/include/sys/types.h"
extern "C" {
#52
typedef long long longlong_t ;
typedef unsigned long long u_longlong_t ;
#72
typedef int32_t t_scalar_t ;
typedef uint32_t t_uscalar_t ;
#82
typedef unsigned char uchar_t ;
typedef unsigned short ushort_t ;
typedef unsigned int uint_t ;
typedef unsigned long ulong_t ;

typedef char * caddr_t ;
typedef long daddr_t ;
typedef short cnt_t ;




typedef long ptrdiff_t ;
#103
typedef ulong_t pfn_t ;
typedef ulong_t pgcnt_t ;
typedef long spgcnt_t ;

typedef uchar_t use_t ;
typedef short sysid_t ;
typedef short index_t ;
typedef void * timeout_id_t ;
typedef void * bufcall_id_t ;
#125
typedef long off_t ;
#132
typedef off_t off64_t ;
#141
typedef ulong_t ino_t ;
typedef long blkcnt_t ;
typedef ulong_t fsblkcnt_t ;
typedef ulong_t fsfilcnt_t ;
#154
typedef ino_t ino64_t ;
typedef blkcnt_t blkcnt64_t ;
typedef fsblkcnt_t fsblkcnt64_t ;
typedef fsfilcnt_t fsfilcnt64_t ;
#167
typedef int blksize_t ;





typedef enum { _B_FALSE , _B_TRUE } boolean_t ;
#191
typedef int64_t pad64_t ;
typedef uint64_t upad64_t ;
#205
typedef union {
long double _q ;
int32_t _l [ 4 ] ;
} pad128_t ;

typedef union {
long double _q ;
uint32_t _l [ 4 ] ;
} upad128_t ;

typedef longlong_t offset_t ;
typedef u_longlong_t u_offset_t ;
typedef u_longlong_t len_t ;
typedef u_longlong_t diskaddr_t ;
#229
typedef union {
offset_t _f ;
struct {
int32_t _l ;
int32_t _u ;
} _p ;
} lloff_t ;
#249
typedef union {
longlong_t _f ;
struct {
int32_t _l ;
int32_t _u ;
} _p ;
} lldaddr_t ;
#268
typedef uint_t k_fltset_t ;
#280
typedef int id_t ;




typedef id_t lgrp_id_t ;





typedef uint_t useconds_t ;



typedef long suseconds_t ;
#302
typedef uint_t major_t ;
typedef uint_t minor_t ;
#312
typedef short pri_t ;





typedef ushort_t cpu_flag_t ;
#331
typedef ushort_t o_mode_t ;
typedef short o_dev_t ;
typedef ushort_t o_uid_t ;
typedef o_uid_t o_gid_t ;
typedef short o_nlink_t ;
typedef short o_pid_t ;
typedef ushort_t o_ino_t ;





typedef int key_t ;

typedef uint_t mode_t ;
#353
typedef int uid_t ;





typedef uid_t gid_t ;

typedef id_t taskid_t ;
typedef id_t projid_t ;
typedef id_t poolid_t ;
typedef id_t zoneid_t ;
typedef id_t ctid_t ;
#372
typedef uint_t pthread_t ;
typedef uint_t pthread_key_t ;
#381
typedef struct _pthread_mutex {
struct {
uint16_t __pthread_mutex_flag1 ;
uint8_t __pthread_mutex_flag2 ;
uint8_t __pthread_mutex_ceiling ;
uint16_t __pthread_mutex_type ;
uint16_t __pthread_mutex_magic ;
} __pthread_mutex_flags ;
union {
struct {
uint8_t __pthread_mutex_pad [ 8 ] ;
} __pthread_mutex_lock64 ;
struct {
uint32_t __pthread_ownerpid ;
uint32_t __pthread_lockword ;
} __pthread_mutex_lock32 ;
upad64_t __pthread_mutex_owner64 ;
} __pthread_mutex_lock ;
upad64_t __pthread_mutex_data ;
} pthread_mutex_t ;

typedef struct _pthread_cond {
struct {
uint8_t __pthread_cond_flag [ 4 ] ;
uint16_t __pthread_cond_type ;
uint16_t __pthread_cond_magic ;
} __pthread_cond_flags ;
upad64_t __pthread_cond_data ;
} pthread_cond_t ;




typedef struct _pthread_rwlock {
int32_t __pthread_rwlock_readers ;
uint16_t __pthread_rwlock_type ;
uint16_t __pthread_rwlock_magic ;
pthread_mutex_t __pthread_rwlock_mutex ;
pthread_cond_t __pthread_rwlock_readercv ;
pthread_cond_t __pthread_rwlock_writercv ;
} pthread_rwlock_t ;




typedef struct {
uint32_t __pthread_barrier_count ;
uint32_t __pthread_barrier_current ;
upad64_t __pthread_barrier_cycle ;
upad64_t __pthread_barrier_reserved ;
pthread_mutex_t __pthread_barrier_lock ;
pthread_cond_t __pthread_barrier_cond ;
} pthread_barrier_t ;

typedef pthread_mutex_t pthread_spinlock_t ;




typedef struct _pthread_attr {
void * __pthread_attrp ;
} pthread_attr_t ;




typedef struct _pthread_mutexattr {
void * __pthread_mutexattrp ;
} pthread_mutexattr_t ;




typedef struct _pthread_condattr {
void * __pthread_condattrp ;
} pthread_condattr_t ;




typedef struct _once {
upad64_t __pthread_once_pad [ 4 ] ;
} pthread_once_t ;





typedef struct _pthread_rwlockattr {
void * __pthread_rwlockattrp ;
} pthread_rwlockattr_t ;





typedef struct {
void * __pthread_barrierattrp ;
} pthread_barrierattr_t ;

typedef ulong_t dev_t ;


typedef uint_t nlink_t ;
typedef int pid_t ;
#494
typedef ulong_t size_t ;
#503
typedef long ssize_t ;
#511
typedef long time_t ;




typedef long clock_t ;




typedef int clockid_t ;




typedef int timer_t ;





typedef unsigned char unchar ;
typedef unsigned short ushort ;
typedef unsigned int uint ;
typedef unsigned long ulong ;
#594
typedef unsigned char u_char ;
typedef unsigned short u_short ;
typedef unsigned int u_int ;
typedef unsigned long u_long ;
typedef struct _quad { int val [ 2 ] ; } quad_t ;
typedef quad_t quad ;
#1 "/usr/include/sys/select.h"
#15
#pragma ident "@(#)select.h 1.19    04/01/28 SMI"
#1 "/usr/include/sys/time_impl.h"
#19
#pragma ident "@(#)time_impl.h  1.11    05/05/19 SMI"
#24
extern "C" {
#31
typedef long time_t ;
#38
typedef struct timespec {
time_t tv_sec ;
long tv_nsec ;
} timespec_t ;
#62
typedef struct timespec timestruc_t ;
#76
typedef struct itimerspec {
struct timespec it_interval ;
struct timespec it_value ;
} itimerspec_t ;
#118
}
#1 "/usr/include/sys/time.h"
#21
#pragma ident "@(#)time.h   2.78    11/10/14 SMI"
#31
extern "C" {
#40
typedef long time_t ;
#48
struct timeval {
time_t tv_sec ;
suseconds_t tv_usec ;
} ;
#80
struct timezone {
int tz_minuteswest ;
int tz_dsttime ;
} ;





}
#1 "/usr/include/sys/types.h"
#102 "/usr/include/sys/time.h"
extern "C" {
#149
struct itimerval {
struct timeval it_interval ;
struct timeval it_value ;
} ;
#196
typedef longlong_t hrtime_t ;
#322
int adjtime ( struct timeval * , struct timeval * ) ;
#331
int futimesat ( int , const char * , const struct timeval * ) ;
#342
int getitimer ( int , struct itimerval * ) ;
int utimes ( const char * , const struct timeval * ) ;

int setitimer ( int , const struct itimerval * ,
struct itimerval * ) ;
#380
int settimeofday ( struct timeval * , void * ) ;

hrtime_t gethrtime ( void ) ;
hrtime_t gethrvtime ( void ) ;
#399
int gettimeofday ( struct timeval * , void * ) ;
#1 "/usr/include/time.h"
#16
#pragma ident "@(#)time.h   1.45    08/01/09 SMI"
#1 "/usr/include/iso/time_iso.h"
#28
#pragma ident "@(#)time_iso.h   1.4 04/09/07 SMI"
#33
extern "C" {



namespace std {
#51
typedef unsigned long size_t ;
#59
typedef long clock_t ;




typedef long time_t ;




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




extern char * asctime ( const struct tm * ) ;
extern clock_t clock ( void ) ;
extern char * ctime ( const time_t * ) ;
extern double difftime ( time_t , time_t ) ;
extern struct tm * gmtime ( const time_t * ) ;
extern struct tm * localtime ( const time_t * ) ;
extern time_t mktime ( struct tm * ) ;
extern time_t time ( time_t * ) ;
extern size_t strftime ( char * , size_t , const char * ,
const struct tm * ) ;
#110
}



}
#1 "/usr/include/sys/types.h"
#31 "/usr/include/time.h"
using std :: size_t ;
using std :: clock_t ;
using std :: time_t ;
using std :: tm ;
using std :: asctime ;
using std :: clock ;
using std :: ctime ;
using std :: difftime ;
using std :: gmtime ;
using std :: localtime ;
using std :: mktime ;
using std :: time ;
using std :: strftime ;



extern "C" {
#65
extern struct tm * gmtime_r ( const time_t * ,
struct tm * ) ;
extern struct tm * localtime_r ( const time_t * ,
struct tm * ) ;
#83
extern char * strptime ( const char * , const char * ,
struct tm * ) ;
#103
union sigval {
int sival_int ;
void * sival_ptr ;
} ;




struct sigevent {
int sigev_notify ;
int sigev_signo ;
union sigval sigev_value ;
void ( * sigev_notify_function ) ( union sigval ) ;
pthread_attr_t * sigev_notify_attributes ;
int __sigev_pad2 ;
} ;


extern int clock_getres ( clockid_t , struct timespec * ) ;
extern int clock_gettime ( clockid_t , struct timespec * ) ;
extern int clock_settime ( clockid_t , const struct timespec * ) ;
extern int timer_create ( clockid_t , struct sigevent * ,
timer_t * ) ;
extern int timer_delete ( timer_t ) ;
extern int timer_getoverrun ( timer_t ) ;
extern int timer_gettime ( timer_t , struct itimerspec * ) ;
extern int timer_settime ( timer_t , int , const struct itimerspec * ,
struct itimerspec * ) ;

extern int nanosleep ( const struct timespec * , struct timespec * ) ;
extern int clock_nanosleep ( clockid_t , int ,
const struct timespec * , struct timespec * ) ;
#141
extern void tzset ( void ) ;
extern char * tzname [ 2 ] ;




extern long _sysconf ( int ) ;
#155
extern long timezone ;
extern int daylight ;
#163
extern int cftime ( char * , char * , const time_t * ) ;
extern int ascftime ( char * , const char * , const struct tm * ) ;
extern long altzone ;




extern struct tm * getdate ( const char * ) ;



extern int * _getdate_err_addr ( void ) ;
#265
#pragma redefine_extname ctime_r __posix_ctime_r
#pragma redefine_extname asctime_r __posix_asctime_r
extern char * asctime_r ( const struct tm * , char * ) ;
extern char * ctime_r ( const time_t * , char * ) ;
#355
}
#1 "/usr/include/sys/select.h"
#437 "/usr/include/sys/time.h"
}
#27 "/usr/include/sys/select.h"
extern "C" {
#44
typedef struct {
unsigned int __sigbits [ 4 ] ;
} sigset_t ;
#88
typedef long fd_mask ;

typedef long fds_mask ;
#116
typedef struct fd_set {



long fds_bits [ ( ( ( 65536 ) + ( ( ( sizeof ( fds_mask ) * 8 ) ) - 1 ) ) / ( ( sizeof ( fds_mask ) * 8 ) ) ) ] ;
} fd_set ;
#140
extern int select ( int , fd_set * , fd_set * ,
fd_set * , struct timeval * ) ;


extern int pselect ( int , fd_set * , fd_set * ,
fd_set * , const struct timespec * ,
const sigset_t * ) ;
#158
}
#631 "/usr/include/sys/types.h"
typedef struct klgrpset {
ulong_t klgb [ 3 ] ;
} klgrpset_t ;


}
#1 "/usr/include/sys/unistd.h"
#23
#pragma ident "@(#)unistd.h 1.46    12/01/17 SMI"
#28
extern "C" {
#383
}
#24 "/usr/include/unistd.h"
extern "C" {
#207
#pragma redefine_extname ftruncate64 ftruncate
#pragma redefine_extname lseek64 lseek
#pragma redefine_extname pread64 pread
#pragma redefine_extname pwrite64 pwrite
#pragma redefine_extname truncate64 truncate
#pragma redefine_extname lockf64 lockf
#pragma redefine_extname tell64 tell
#227
extern int access ( const char * , int ) ;

extern int acct ( const char * ) ;

extern unsigned alarm ( unsigned ) ;



extern int brk ( void * ) ;

extern int chdir ( const char * ) ;
extern int chown ( const char * , uid_t , gid_t ) ;



extern int chroot ( const char * ) ;

extern int close ( int ) ;

extern size_t confstr ( int , char * , size_t ) ;
extern char * crypt ( const char * , const char * ) ;



extern char * ctermid ( char * ) ;


extern char * ctermid_r ( char * ) ;



extern char * cuserid ( char * ) ;

extern int dup ( int ) ;
extern int dup2 ( int , int ) ;

extern void encrypt ( char * , int ) ;


extern void endusershell ( void ) ;

extern int execl ( const char * , const char * , ... ) ;
extern int execle ( const char * , const char * , ... ) ;
extern int execlp ( const char * , const char * , ... ) ;
extern int execv ( const char * , char * const * ) ;
extern int execve ( const char * , char * const * , char * const * ) ;
extern int execvp ( const char * , char * const * ) ;
extern void _exit ( int )
;
#282
extern int fattach ( int , const char * ) ;


extern int fchdir ( int ) ;
extern int fchown ( int , uid_t , gid_t ) ;


extern int fchownat ( int , const char * , uid_t , gid_t , int ) ;



extern int fchroot ( int ) ;



extern int fdatasync ( int ) ;
#305
extern int fdetach ( const char * ) ;

extern pid_t fork ( void ) ;

extern pid_t fork1 ( void ) ;
extern pid_t forkall ( void ) ;

extern long fpathconf ( int , int ) ;


extern int fsync ( int ) ;




extern int ftruncate ( int , off_t ) ;

extern char * getcwd ( char * , size_t ) ;


extern int getdtablesize ( void ) ;

extern gid_t getegid ( void ) ;
extern uid_t geteuid ( void ) ;
extern gid_t getgid ( void ) ;
extern int getgroups ( int , gid_t * ) ;

extern long gethostid ( void ) ;


extern int gethostname ( char * , size_t ) ;



extern char * getlogin ( void ) ;

extern int getopt ( int , char * const * , const char * ) ;
extern char * optarg ;
extern int opterr , optind , optopt ;


extern char * getpass ( const char * ) ;





extern int getpagesize ( void ) ;

extern pid_t getpgid ( pid_t ) ;

extern pid_t getpid ( void ) ;
extern pid_t getppid ( void ) ;
extern pid_t getpgrp ( void ) ;


char * gettxt ( const char * , const char * ) ;


extern pid_t getsid ( pid_t ) ;

extern uid_t getuid ( void ) ;

extern char * getusershell ( void ) ;


extern char * getwd ( char * ) ;
#379
extern int ioctl ( int , int , ... ) ;
extern int isaexec ( const char * , char * const * , char * const * ) ;
extern int issetugid ( void ) ;

extern int isatty ( int ) ;

extern int lchown ( const char * , uid_t , gid_t ) ;

extern int link ( const char * , const char * ) ;

extern offset_t llseek ( int , offset_t , int ) ;




extern int lockf ( int , int , off_t ) ;

extern off_t lseek ( int , off_t , int ) ;


extern int nice ( int ) ;


extern int mincore ( caddr_t , size_t , char * ) ;

extern long pathconf ( const char * , int ) ;
extern int pause ( void ) ;
extern int pipe ( int * ) ;



extern ssize_t pread ( int , void * , size_t , off_t ) ;


extern void profil ( unsigned short * , size_t , unsigned long , unsigned int ) ;
#425
extern int pthread_atfork ( void ( * ) ( void ) , void ( * ) ( void ) , void ( * ) ( void ) ) ;
#434
extern ssize_t pwrite ( int , const void * , size_t , off_t ) ;



extern int rcmd_af ( char * * , unsigned short , const char * , const char * ,
const char * , int * , int ) ;

extern ssize_t read ( int , void * , size_t ) ;


extern ssize_t readlink ( const char * , char * ,
size_t ) ;



extern int rename ( const char * , const char * ) ;



extern int renameat ( int , const char * , int , const char * ) ;


extern int resolvepath ( const char * , char * , size_t ) ;

extern int rexec_af ( char * * , unsigned short , const char * , const char * ,
const char * , int * , int ) ;

extern int rmdir ( const char * ) ;


extern int rresvport_af ( int * , int ) ;




extern void * sbrk ( intptr_t ) ;


extern int setegid ( gid_t ) ;
extern int seteuid ( uid_t ) ;

extern int setgid ( gid_t ) ;

extern int setgroups ( int , const gid_t * ) ;

extern int setpgid ( pid_t , pid_t ) ;

extern pid_t setpgrp ( void ) ;
extern int setregid ( gid_t , gid_t ) ;
extern int setreuid ( uid_t , uid_t ) ;

extern pid_t setsid ( void ) ;
extern int setuid ( uid_t ) ;

extern void setusershell ( void ) ;

extern unsigned sleep ( unsigned ) ;

extern int stime ( const time_t * ) ;



extern void swab ( const void * , void * , ssize_t ) ;


extern int symlink ( const char * , const char * ) ;
extern void sync ( void ) ;



#pragma redefine_extname sysconf __sysconf_xpg5




extern long sysconf ( int ) ;
extern pid_t tcgetpgrp ( int ) ;
extern int tcsetpgrp ( int , pid_t ) ;



extern off_t tell ( int ) ;




extern int truncate ( const char * , off_t ) ;

extern char * ttyname ( int ) ;

extern useconds_t ualarm ( useconds_t , useconds_t ) ;

extern int unlink ( const char * ) ;


extern int unlinkat ( int , const char * , int ) ;


extern int usleep ( useconds_t ) ;


extern pid_t vfork ( void ) ;


extern void vhangup ( void ) ;

extern ssize_t write ( int , const void * , size_t ) ;

extern void yield ( void ) ;





extern int ftruncate64 ( int , off64_t ) ;
extern off64_t lseek64 ( int , off64_t , int ) ;
extern ssize_t pread64 ( int , void * , size_t , off64_t ) ;
extern ssize_t pwrite64 ( int , const void * , size_t , off64_t ) ;
extern off64_t tell64 ( int ) ;
extern int truncate64 ( const char * , off64_t ) ;
extern int lockf64 ( int , int , off64_t ) ;
#911
#pragma redefine_extname getlogin_r __posix_getlogin_r
#pragma redefine_extname ttyname_r __posix_ttyname_r
extern int getlogin_r ( char * , int ) ;
extern int ttyname_r ( int , char * , size_t ) ;
#999
}
#1 "./boost/config/select_platform_config.hpp"
#1 "./boost/config/platform/solaris.hpp"
#1 "./boost/config/posix_features.hpp"
#1 "./boost/config/suffix.hpp"
#482
namespace boost {




typedef long long long_long_type ;
typedef unsigned long long ulong_long_type ;

}
#1 "./boost/regex/config/cwchar.hpp"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cwchar"
#39
#pragma GCC system_header
#1 "/usr/include/wchar.h"
#9
#pragma ident "@(#)wchar.h  1.37    03/12/04 SMI"
#1 "/usr/include/iso/wchar_iso.h"
#21
#pragma ident "@(#)wchar_iso.h  1.8 04/09/28 SMI"
#1 "/usr/include/stdio_tag.h"
#9
#pragma ident "@(#)stdio_tag.h  1.4 04/09/28 SMI"


extern "C" {
#21
typedef struct __FILE __FILE ;



}
#1 "/usr/include/wchar_impl.h"
#9
#pragma ident "@(#)wchar_impl.h 1.3 99/07/26 SMI"
#14
extern "C" {




typedef struct __mbstate_t {

long __filler [ 4 ] ;



} __mbstate_t ;



}
#1 "/usr/include/stdio.h"
#19
#pragma ident "@(#)stdio.h  1.85    11/01/07 SMI"
#24
extern "C" {
#49
#pragma redefine_extname fopen64 fopen
#pragma redefine_extname freopen64 freopen
#pragma redefine_extname tmpfile64 tmpfile
#pragma redefine_extname fgetpos64 fgetpos
#pragma redefine_extname fsetpos64 fsetpos

#pragma redefine_extname fseeko64 fseeko
#pragma redefine_extname ftello64 ftello
#63
}
#1 "/usr/include/iso/stdio_iso.h"
#32
#pragma ident "@(#)stdio_iso.h  1.8 05/08/16 SMI"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/sys/va_list.h"
#1 "/usr/include/sys/va_list.h"
#16
#pragma ident "@(#)va_list.h    1.15    04/11/19 SMI"
#54
extern "C" {
#79
typedef struct __va_list_element {
unsigned int __va_gp_offset ;
unsigned int __va_fp_offset ;
void * __va_overflow_arg_area ;
void * __va_reg_sve_area ;
} __unused_va_list [ 1 ] ;
#114
}
#20 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/sys/va_list.h"
typedef __builtin_va_list __va_list ;
#1 "/usr/include/stdio_impl.h"
#9
#pragma ident "@(#)stdio_impl.h 1.15    07/03/05 SMI"
#14
extern "C" {
#21
struct __FILE {
long __pad [ 16 ] ;
} ;
#53
}
#48 "/usr/include/iso/stdio_iso.h"
extern "C" {
#69
namespace std {




typedef __FILE FILE ;





typedef unsigned long size_t ;
#87
typedef long fpos_t ;





}
#146
extern __FILE __iob [ 20 ] ;
#158
namespace std {
#189
extern int remove ( const char * ) ;
extern int rename ( const char * , const char * ) ;
extern FILE * tmpfile ( void ) ;
extern char * tmpnam ( char * ) ;
extern int fclose ( FILE * ) ;
extern int fflush ( FILE * ) ;
extern FILE * fopen ( const char * , const char * ) ;
extern FILE * freopen ( const char * ,
const char * , FILE * ) ;
extern void setbuf ( FILE * , char * ) ;
extern int setvbuf ( FILE * , char * , int ,
size_t ) ;

extern int fprintf ( FILE * , const char * , ... ) ;

extern int fscanf ( FILE * , const char * , ... ) ;

extern int printf ( const char * , ... ) ;

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

extern int sprintf ( char * , const char * , ... ) ;

extern int sscanf ( const char * ,
const char * , ... ) ;
extern int vfprintf ( FILE * , const char * ,
__va_list ) ;
extern int vprintf ( const char * , __va_list ) ;
extern int vsprintf ( char * , const char * ,
__va_list ) ;
extern int fgetc ( FILE * ) ;
extern char * fgets ( char * , int , FILE * ) ;
extern int fputc ( int , FILE * ) ;
extern int fputs ( const char * , FILE * ) ;


extern int getc ( FILE * ) ;
extern int putc ( int , FILE * ) ;



extern int getchar ( void ) ;
extern int putchar ( int ) ;

extern char * gets ( char * ) ;
extern int puts ( const char * ) ;
extern int ungetc ( int , FILE * ) ;
extern size_t fread ( void * , size_t , size_t ,
FILE * ) ;
extern size_t fwrite ( const void * , size_t , size_t ,
FILE * ) ;

extern int fgetpos ( FILE * , fpos_t * ) ;
extern int fsetpos ( FILE * , const fpos_t * ) ;

extern int fseek ( FILE * , long , int ) ;
extern long ftell ( FILE * ) ;
extern void rewind ( FILE * ) ;


extern void clearerr ( FILE * ) ;
extern int feof ( FILE * ) ;
extern int ferror ( FILE * ) ;

extern void perror ( const char * ) ;
#312
}
#372
}
#81 "/usr/include/stdio.h"
using std :: FILE ;
using std :: size_t ;
using std :: fpos_t ;
using std :: remove ;
using std :: rename ;
using std :: tmpfile ;
using std :: tmpnam ;
using std :: fclose ;
using std :: fflush ;
using std :: fopen ;
using std :: freopen ;
using std :: setbuf ;
using std :: setvbuf ;
using std :: fprintf ;
using std :: fscanf ;
using std :: printf ;
using std :: scanf ;
using std :: sprintf ;
using std :: sscanf ;
using std :: vfprintf ;
using std :: vprintf ;
using std :: vsprintf ;
using std :: fgetc ;
using std :: fgets ;
using std :: fputc ;
using std :: fputs ;
using std :: getc ;
using std :: getchar ;
using std :: gets ;
using std :: putc ;
using std :: putchar ;
using std :: puts ;
using std :: ungetc ;
using std :: fread ;
using std :: fwrite ;
using std :: fgetpos ;
using std :: fseek ;
using std :: fsetpos ;
using std :: ftell ;
using std :: rewind ;
using std :: clearerr ;
using std :: feof ;
using std :: ferror ;
using std :: perror ;
#1 "/usr/include/iso/stdio_c99.h"
#20
#pragma ident "@(#)stdio_c99.h  1.2 04/03/29 SMI"


extern "C" {
#54
extern int vfscanf ( FILE * , const char * , __va_list ) ;
extern int vscanf ( const char * , __va_list ) ;
extern int vsscanf ( const char * , const char * ,
__va_list ) ;
#68
extern int snprintf ( char * , size_t , const char * ,
... ) ;
extern int vsnprintf ( char * , size_t , const char * ,
__va_list ) ;
#80
}
#138 "/usr/include/stdio.h"
extern "C" {
#161
typedef fpos_t fpos64_t ;
#174
typedef __va_list va_list ;
#197
extern unsigned char _sibuf [ ] , _sobuf [ ] ;
#253
extern char * tmpnam_r ( char * ) ;




extern void setbuffer ( FILE * , char * , size_t ) ;
extern int setlinebuf ( FILE * ) ;

extern int asprintf ( char * * , const char * , ... ) ;

extern int vasprintf ( char * * , const char * , __va_list ) ;
#272
extern FILE * fdopen ( int , const char * ) ;
extern char * ctermid ( char * ) ;
extern int fileno ( FILE * ) ;
#283
extern void flockfile ( FILE * ) ;
extern int ftrylockfile ( FILE * ) ;
extern void funlockfile ( FILE * ) ;
extern int getc_unlocked ( FILE * ) ;
extern int getchar_unlocked ( void ) ;
extern int putc_unlocked ( int , FILE * ) ;
extern int putchar_unlocked ( int ) ;
#298
extern FILE * popen ( const char * , const char * ) ;
extern char * tempnam ( const char * , const char * ) ;
extern int pclose ( FILE * ) ;
#307
extern char * cuserid ( char * ) ;
extern int getopt ( int , char * const * , const char * ) ;
extern char * optarg ;
extern int optind , opterr , optopt ;
extern int getw ( FILE * ) ;
extern int putw ( int , FILE * ) ;
#321
extern int fseeko ( FILE * , off_t , int ) ;
extern off_t ftello ( FILE * ) ;
#331
extern FILE * fopen64 ( const char * , const char * ) ;
extern FILE * freopen64 ( const char * , const char * , FILE * ) ;
extern FILE * tmpfile64 ( void ) ;
extern int fgetpos64 ( FILE * , fpos64_t * ) ;
extern int fsetpos64 ( FILE * , const fpos64_t * ) ;
extern int fseeko64 ( FILE * , off64_t , int ) ;
extern off64_t ftello64 ( FILE * ) ;
#445
}
#1 "/usr/include/ctype.h"
#16
#pragma ident "@(#)ctype.h  1.35    04/09/28 SMI"
#1 "/usr/include/iso/ctype_iso.h"
#28
#pragma ident "@(#)ctype_iso.h  1.3 04/09/28 SMI"
#33
extern "C" {
#78
namespace std {


extern int tolower ( int ) ;
extern int toupper ( int ) ;


}


extern unsigned char __ctype [ ] ;
extern unsigned int * __ctype_mask ;
extern int * __trans_upper ;
extern int * __trans_lower ;




namespace std {



inline int isalpha ( int c ) { return ( __ctype_mask [ c ] & 0x00004000 ) ; }
inline int isupper ( int c ) { return ( __ctype_mask [ c ] & 0x00000001 ) ; }
inline int islower ( int c ) { return ( __ctype_mask [ c ] & 0x00000002 ) ; }
inline int isdigit ( int c ) { return ( __ctype_mask [ c ] & 0x00000004 ) ; }
inline int isxdigit ( int c ) { return ( __ctype_mask [ c ] & 0x00000080 ) ; }
inline int isalnum ( int c ) { return ( __ctype_mask [ c ] & ( 0x00004000 | 0x00000004 ) ) ; }
inline int isspace ( int c ) { return ( __ctype_mask [ c ] & 0x00000008 ) ; }
inline int ispunct ( int c ) { return ( __ctype_mask [ c ] & 0x00000010 ) ; }
inline int isprint ( int c ) { return ( __ctype_mask [ c ] & 0x00008000 ) ; }
inline int isgraph ( int c ) { return ( __ctype_mask [ c ] & 0x00002000 ) ; }
inline int iscntrl ( int c ) { return ( __ctype_mask [ c ] & 0x00000020 ) ; }
#126
}
#184
}
#1 "/usr/include/iso/ctype_c99.h"
#20
#pragma ident "@(#)ctype_c99.h  1.2 04/09/28 SMI"


extern "C" {
#38
extern int isblank ( int ) ;
#62
}
#26 "/usr/include/ctype.h"
using std :: isalnum ;
using std :: isalpha ;
using std :: iscntrl ;
using std :: isdigit ;
using std :: isgraph ;
using std :: islower ;
using std :: isprint ;
using std :: ispunct ;
using std :: isspace ;
using std :: isupper ;
using std :: isxdigit ;
using std :: tolower ;
using std :: toupper ;



extern "C" {
#51
extern int isascii ( int ) ;
extern int toascii ( int ) ;
extern int _tolower ( int ) ;
extern int _toupper ( int ) ;
#91
}
#42 "/usr/include/iso/wchar_iso.h"
extern "C" {



namespace std {
#76
typedef int wint_t ;
#85
typedef unsigned long size_t ;
#115
typedef __mbstate_t mbstate_t ;




typedef __FILE FILE ;
#153
#pragma redefine_extname fgetwc __fgetwc_xpg5
#pragma redefine_extname getwc __getwc_xpg5
#pragma redefine_extname getwchar __getwchar_xpg5
#pragma redefine_extname fputwc __fputwc_xpg5
#pragma redefine_extname putwc __putwc_xpg5
#pragma redefine_extname putwchar __putwchar_xpg5
#pragma redefine_extname fgetws __fgetws_xpg5
#pragma redefine_extname fputws __fputws_xpg5
#pragma redefine_extname ungetwc __ungetwc_xpg5
#200
extern wint_t fgetwc ( __FILE * ) ;
extern wchar_t * fgetws ( wchar_t * , int , __FILE * ) ;
extern wint_t fputwc ( wint_t , __FILE * ) ;
extern int fputws ( const wchar_t * , __FILE * ) ;
extern wint_t ungetwc ( wint_t , __FILE * ) ;
extern wint_t getwc ( __FILE * ) ;
extern wint_t getwchar ( void ) ;
extern wint_t putwc ( wint_t , __FILE * ) ;
extern wint_t putwchar ( wint_t ) ;
extern double wcstod ( const wchar_t * , wchar_t * * ) ;
extern long wcstol ( const wchar_t * , wchar_t * * ,
int ) ;
extern unsigned long wcstoul ( const wchar_t * ,
wchar_t * * , int ) ;
extern wchar_t * wcscat ( wchar_t * , const wchar_t * ) ;
extern int wcscmp ( const wchar_t * , const wchar_t * ) ;
extern int wcscoll ( const wchar_t * , const wchar_t * ) ;
extern wchar_t * wcscpy ( wchar_t * , const wchar_t * ) ;
extern size_t wcscspn ( const wchar_t * , const wchar_t * ) ;
extern size_t wcslen ( const wchar_t * ) ;
extern wchar_t * wcsncat ( wchar_t * , const wchar_t * ,
size_t ) ;
extern int wcsncmp ( const wchar_t * , const wchar_t * , size_t ) ;
extern wchar_t * wcsncpy ( wchar_t * , const wchar_t * ,
size_t ) ;
extern size_t wcsspn ( const wchar_t * , const wchar_t * ) ;
extern size_t wcsxfrm ( wchar_t * , const wchar_t * ,
size_t ) ;

extern const wchar_t * wcschr ( const wchar_t * , wchar_t ) ;
extern "C++" {
inline wchar_t * wcschr ( wchar_t * __ws , wchar_t __wc ) {
return ( wchar_t * ) wcschr ( ( const wchar_t * ) __ws , __wc ) ;
}
}
extern const wchar_t * wcspbrk ( const wchar_t * , const wchar_t * ) ;
extern "C++" {
inline wchar_t * wcspbrk ( wchar_t * __ws1 , const wchar_t * __ws2 ) {
return ( wchar_t * ) wcspbrk ( ( const wchar_t * ) __ws1 , __ws2 ) ;
}
}
extern const wchar_t * wcsrchr ( const wchar_t * , wchar_t ) ;
extern "C++" {
inline wchar_t * wcsrchr ( wchar_t * __ws , wchar_t __wc ) {
return ( wchar_t * ) wcsrchr ( ( const wchar_t * ) __ws , __wc ) ;
}
}
#259
#pragma redefine_extname wcstok __wcstok_xpg5
#pragma redefine_extname wcsftime __wcsftime_xpg5
extern wchar_t * wcstok ( wchar_t * , const wchar_t * ,
wchar_t * * ) ;
extern size_t wcsftime ( wchar_t * , size_t ,
const wchar_t * , const struct tm * ) ;
#278
extern wint_t btowc ( int ) ;
extern int fwprintf ( __FILE * , const wchar_t * ,
... ) ;
extern int fwscanf ( __FILE * , const wchar_t * ,
... ) ;
extern int fwide ( __FILE * , int ) ;
extern int mbsinit ( const mbstate_t * ) ;
extern size_t mbrlen ( const char * , size_t ,
mbstate_t * ) ;
extern size_t mbrtowc ( wchar_t * , const char * ,
size_t , mbstate_t * ) ;
extern size_t mbsrtowcs ( wchar_t * , const char * * ,
size_t , mbstate_t * ) ;
extern int swprintf ( wchar_t * , size_t ,
const wchar_t * , ... ) ;
extern int swscanf ( const wchar_t * ,
const wchar_t * , ... ) ;
extern int vfwprintf ( __FILE * , const wchar_t * ,
__va_list ) ;
extern int vwprintf ( const wchar_t * , __va_list ) ;
extern int vswprintf ( wchar_t * , size_t ,
const wchar_t * , __va_list ) ;
extern size_t wcrtomb ( char * , wchar_t ,
mbstate_t * ) ;
extern size_t wcsrtombs ( char * , const wchar_t * * ,
size_t , mbstate_t * ) ;
extern int wctob ( wint_t ) ;
extern int wmemcmp ( const wchar_t * , const wchar_t * , size_t ) ;
extern wchar_t * wmemcpy ( wchar_t * ,
const wchar_t * , size_t ) ;
extern wchar_t * wmemmove ( wchar_t * , const wchar_t * , size_t ) ;
extern wchar_t * wmemset ( wchar_t * , wchar_t , size_t ) ;
extern int wprintf ( const wchar_t * , ... ) ;
extern int wscanf ( const wchar_t * , ... ) ;

extern const wchar_t * wcsstr ( const wchar_t * , const wchar_t * ) ;
extern "C++" {
inline wchar_t * wcsstr ( wchar_t * __ws1 , const wchar_t * __ws2 ) {
return ( wchar_t * ) wcsstr ( ( const wchar_t * ) __ws1 , __ws2 ) ;
}
}
extern const wchar_t * wmemchr ( const wchar_t * , wchar_t , size_t ) ;
extern "C++" {
inline wchar_t * wmemchr ( wchar_t * __ws , wchar_t __wc , size_t __n ) {
return ( wchar_t * ) wmemchr ( ( const wchar_t * ) __ws , __wc , __n ) ;
}
}
#412
}



}
#1 "/usr/include/iso/wchar_c99.h"
#20
#pragma ident "@(#)wchar_c99.h  1.3 04/03/29 SMI"


extern "C" {
#45
extern int vfwscanf ( __FILE * , const wchar_t * ,
__va_list ) ;
extern int vswscanf ( const wchar_t * ,
const wchar_t * , __va_list ) ;
extern int vwscanf ( const wchar_t * , __va_list ) ;
extern float wcstof ( const wchar_t * ,
wchar_t * * ) ;

extern long double wcstold ( const wchar_t * ,
wchar_t * * ) ;
extern long long wcstoll ( const wchar_t * ,
wchar_t * * , int ) ;
extern unsigned long long wcstoull ( const wchar_t * ,
wchar_t * * , int ) ;
#78
}
#21 "/usr/include/wchar.h"
using std :: FILE ;
using std :: wint_t ;
using std :: clock_t ;
using std :: size_t ;
using std :: time_t ;
using std :: tm ;
using std :: mbstate_t ;
using std :: fgetwc ;
using std :: fgetws ;
using std :: fputwc ;
using std :: fputws ;
using std :: ungetwc ;
using std :: getwc ;
using std :: getwchar ;
using std :: putwc ;
using std :: putwchar ;
using std :: wcstod ;
using std :: wcstol ;
using std :: wcstoul ;
using std :: wcscat ;
using std :: wcschr ;
using std :: wcscmp ;
using std :: wcscoll ;
using std :: wcscpy ;
using std :: wcscspn ;
using std :: wcslen ;
using std :: wcsncat ;
using std :: wcsncmp ;
using std :: wcsncpy ;
using std :: wcspbrk ;
using std :: wcsrchr ;
using std :: wcsspn ;
using std :: wcsxfrm ;
using std :: wcstok ;
using std :: wcsftime ;


using std :: btowc ;
using std :: fwprintf ;
using std :: fwscanf ;
using std :: fwide ;
using std :: mbsinit ;
using std :: mbrlen ;
using std :: mbrtowc ;
using std :: mbsrtowcs ;
using std :: swprintf ;
using std :: swscanf ;
using std :: vfwprintf ;
using std :: vwprintf ;
using std :: vswprintf ;
using std :: wcrtomb ;
using std :: wcsrtombs ;
using std :: wcsstr ;
using std :: wctob ;
using std :: wmemchr ;
using std :: wmemcmp ;
using std :: wmemcpy ;
using std :: wmemmove ;
using std :: wmemset ;
using std :: wprintf ;
using std :: wscanf ;




extern "C" {





typedef int wctype_t ;
#108
extern int iswalpha ( wint_t ) ;
extern int iswupper ( wint_t ) ;
extern int iswlower ( wint_t ) ;
extern int iswdigit ( wint_t ) ;
extern int iswxdigit ( wint_t ) ;
extern int iswalnum ( wint_t ) ;
extern int iswspace ( wint_t ) ;
extern int iswpunct ( wint_t ) ;
extern int iswprint ( wint_t ) ;
extern int iswgraph ( wint_t ) ;
extern int iswcntrl ( wint_t ) ;
extern int iswctype ( wint_t , wctype_t ) ;
extern wint_t towlower ( wint_t ) ;
extern wint_t towupper ( wint_t ) ;
extern wchar_t * wcswcs ( const wchar_t * , const wchar_t * ) ;
extern int wcswidth ( const wchar_t * , size_t ) ;
extern int wcwidth ( const wchar_t ) ;
extern wctype_t wctype ( const char * ) ;
#154
}
#62 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cwchar"
namespace std
{
using :: mbstate_t ;
}
#135
namespace std
{


using :: wint_t ;

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

using :: swprintf ;

using :: swscanf ;
using :: ungetwc ;
using :: vfwprintf ;

using :: vfwscanf ;


using :: vswprintf ;


using :: vswscanf ;

using :: vwprintf ;

using :: vwscanf ;

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

using :: wcstof ;

using :: wcstok ;
using :: wcstol ;
using :: wcstoul ;
using :: wcsxfrm ;
using :: wctob ;
using :: wmemcmp ;
using :: wmemcpy ;
using :: wmemmove ;
using :: wmemset ;
using :: wprintf ;
using :: wscanf ;
using :: wcschr ;
using :: wcspbrk ;
using :: wcsrchr ;
using :: wcsstr ;
using :: wmemchr ;
#233
}
#241
namespace __gnu_cxx
{





using :: wcstold ;
#257
using :: wcstoll ;
using :: wcstoull ;

}

namespace std
{
using :: __gnu_cxx :: wcstold ;
using :: __gnu_cxx :: wcstoll ;
using :: __gnu_cxx :: wcstoull ;
}
#277
namespace std
{

using std :: wcstof ;


using std :: vfwscanf ;


using std :: vswscanf ;


using std :: vwscanf ;



using std :: wcstold ;
using std :: wcstoll ;
using std :: wcstoull ;

}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cwctype"
#39
#pragma GCC system_header
#1 "/usr/include/wctype.h"
#13
#pragma ident "@(#)wctype.h 1.19    03/12/04 SMI"
#1 "/usr/include/iso/wctype_iso.h"
#25
#pragma ident "@(#)wctype_iso.h 1.2 03/12/04 SMI"
#30
extern "C" {



namespace std {





typedef int wint_t ;
#48
typedef int wctype_t ;


typedef unsigned int wctrans_t ;
#61
extern int iswalnum ( wint_t ) ;
extern int iswalpha ( wint_t ) ;
extern int iswcntrl ( wint_t ) ;
extern int iswdigit ( wint_t ) ;
extern int iswgraph ( wint_t ) ;
extern int iswlower ( wint_t ) ;
extern int iswprint ( wint_t ) ;
extern int iswpunct ( wint_t ) ;
extern int iswspace ( wint_t ) ;
extern int iswupper ( wint_t ) ;
extern int iswxdigit ( wint_t ) ;

extern wint_t towlower ( wint_t ) ;
extern wint_t towupper ( wint_t ) ;
extern wctrans_t wctrans ( const char * ) ;
extern wint_t towctrans ( wint_t , wctrans_t ) ;
extern int iswctype ( wint_t , wctype_t ) ;
extern wctype_t wctype ( const char * ) ;
#129
}



}
#27 "/usr/include/wctype.h"
using std :: wint_t ;
using std :: wctrans_t ;
using std :: iswalnum ;
using std :: iswalpha ;
using std :: iswcntrl ;
using std :: iswdigit ;
using std :: iswgraph ;
using std :: iswlower ;
using std :: iswprint ;
using std :: iswpunct ;
using std :: iswspace ;
using std :: iswupper ;
using std :: iswxdigit ;
using std :: towlower ;
using std :: towupper ;
using std :: wctrans ;
using std :: towctrans ;
using std :: iswctype ;
using std :: wctype ;
#1 "/usr/include/iso/wctype_c99.h"
#20
#pragma ident "@(#)wctype_c99.h 1.1 03/12/04 SMI"


extern "C" {
#48
extern int iswblank ( wint_t ) ;
#55
}
#56 "/usr/include/wctype.h"
extern "C" {
#67
struct _wctype {
wchar_t tmin ;
wchar_t tmax ;
unsigned char * index ;
unsigned int * type ;
wchar_t cmin ;
wchar_t cmax ;
wchar_t * code ;
} ;
#85
extern unsigned _iswctype ( wchar_t , int ) ;
extern wchar_t _trwctype ( wchar_t , int ) ;

extern int isphonogram ( wint_t ) ;
extern int isideogram ( wint_t ) ;
extern int isenglish ( wint_t ) ;
extern int isnumber ( wint_t ) ;
extern int isspecial ( wint_t ) ;
#113
}
#80 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cwctype"
namespace std
{
using :: wctrans_t ;
using :: wctype_t ;
using :: wint_t ;

using :: iswalnum ;
using :: iswalpha ;

using :: iswblank ;

using :: iswcntrl ;
using :: iswctype ;
using :: iswdigit ;
using :: iswgraph ;
using :: iswlower ;
using :: iswprint ;
using :: iswpunct ;
using :: iswspace ;
using :: iswupper ;
using :: iswxdigit ;
using :: towctrans ;
using :: towlower ;
using :: towupper ;
using :: wctrans ;
using :: wctype ;
}
#49 "./boost/regex/config/cwchar.hpp"
namespace std {


extern "C" {
#201
}


}
#390 "./boost/regex/config.hpp"
namespace boost { namespace re_detail {

void * get_mem_block ( ) ;
void put_mem_block ( void * ) ;

} }
#1 "./boost/regex/v4/regex.hpp"
#1 "./boost/regex/v4/regex_workaround.hpp"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/new"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/exception"
#33
#pragma GCC system_header

#pragma GCC visibility push ( default )
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/atomic_lockfree_defines.h"
#33
#pragma GCC system_header
#40 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/exception"
extern "C++" {

namespace std
{
#60
class exception
{
public :
exception ( ) noexcept { }
virtual ~ exception ( ) noexcept ;



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



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



virtual ~ bad_exception ( ) noexcept ;


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


typedef void ( * terminate_handler ) ( ) ;


typedef void ( * unexpected_handler ) ( ) ;


terminate_handler set_terminate ( terminate_handler ) noexcept ;



void terminate ( ) noexcept __attribute__ ( ( __noreturn__ ) ) ;


unexpected_handler set_unexpected ( unexpected_handler ) noexcept ;



void unexpected ( ) __attribute__ ( ( __noreturn__ ) ) ;
#117
bool uncaught_exception ( ) noexcept __attribute__ ( ( __pure__ ) ) ;


}

namespace __gnu_cxx
{
#142
void __verbose_terminate_handler ( ) ;


}

}

#pragma GCC visibility pop
#42 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/new"
#pragma GCC visibility push ( default )

extern "C++" {

namespace std
{
#54
class bad_alloc : public exception
{
public :
bad_alloc ( ) throw ( ) { }



virtual ~ bad_alloc ( ) throw ( ) ;


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

struct nothrow_t { } ;

extern const nothrow_t nothrow ;



typedef void ( * new_handler ) ( ) ;



new_handler set_new_handler ( new_handler ) throw ( ) ;
}
#91
void * operator new ( std :: size_t )
__attribute__ ( ( __externally_visible__ ) ) ;
void * operator new [ ] ( std :: size_t )
__attribute__ ( ( __externally_visible__ ) ) ;
void operator delete ( void * ) noexcept
__attribute__ ( ( __externally_visible__ ) ) ;
void operator delete [ ] ( void * ) noexcept
__attribute__ ( ( __externally_visible__ ) ) ;
void * operator new ( std :: size_t , const std :: nothrow_t & ) noexcept
__attribute__ ( ( __externally_visible__ ) ) ;
void * operator new [ ] ( std :: size_t , const std :: nothrow_t & ) noexcept
__attribute__ ( ( __externally_visible__ ) ) ;
void operator delete ( void * , const std :: nothrow_t & ) noexcept
__attribute__ ( ( __externally_visible__ ) ) ;
void operator delete [ ] ( void * , const std :: nothrow_t & ) noexcept
__attribute__ ( ( __externally_visible__ ) ) ;


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


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

}

#pragma GCC visibility pop
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstring"
#39
#pragma GCC system_header
#1 "/usr/include/string.h"
#16
#pragma ident "@(#)string.h 1.27    07/01/14 SMI"
#1 "/usr/include/iso/string_iso.h"
#28
#pragma ident "@(#)string_iso.h 1.5 04/06/18 SMI"
#33
extern "C" {



namespace std {





typedef unsigned long size_t ;
#59
extern int memcmp ( const void * , const void * , size_t ) ;
extern void * memcpy ( void * , const void * , size_t ) ;
extern void * memmove ( void * , const void * , size_t ) ;
extern void * memset ( void * , int , size_t ) ;
extern char * strcat ( char * , const char * ) ;
extern int strcmp ( const char * , const char * ) ;
extern char * strcpy ( char * , const char * ) ;
extern int strcoll ( const char * , const char * ) ;
extern size_t strcspn ( const char * , const char * ) ;
extern char * strerror ( int ) ;
extern size_t strlen ( const char * ) ;
extern char * strncat ( char * , const char * , size_t ) ;
extern int strncmp ( const char * , const char * , size_t ) ;
extern char * strncpy ( char * , const char * , size_t ) ;
extern size_t strspn ( const char * , const char * ) ;
extern char * strtok ( char * , const char * ) ;
extern size_t strxfrm ( char * , const char * , size_t ) ;
#83
extern const void * memchr ( const void * , int , size_t ) ;


extern "C++" {
inline void * memchr ( void * __s , int __c , size_t __n ) {
return ( void * ) memchr ( ( const void * ) __s , __c , __n ) ;
}
}

extern const char * strchr ( const char * , int ) ;


extern "C++" {
inline char * strchr ( char * __s , int __c ) {
return ( char * ) strchr ( ( const char * ) __s , __c ) ;
}
}

extern const char * strpbrk ( const char * , const char * ) ;


extern "C++" {
inline char * strpbrk ( char * __s1 , const char * __s2 ) {
return ( char * ) strpbrk ( ( const char * ) __s1 , __s2 ) ;
}
}

extern const char * strrchr ( const char * , int ) ;


extern "C++" {
inline char * strrchr ( char * __s , int __c ) {
return ( char * ) strrchr ( ( const char * ) __s , __c ) ;
}
}

extern const char * strstr ( const char * , const char * ) ;


extern "C++" {
inline char * strstr ( char * __s1 , const char * __s2 ) {
return ( char * ) strstr ( ( const char * ) __s1 , __s2 ) ;
}
}
#164
}



}
#25 "/usr/include/string.h"
using std :: size_t ;
using std :: memchr ;
using std :: memcmp ;
using std :: memcpy ;
using std :: memmove ;
using std :: memset ;
using std :: strcat ;
using std :: strchr ;
using std :: strcmp ;
using std :: strcoll ;
using std :: strcpy ;
using std :: strcspn ;
using std :: strerror ;
using std :: strlen ;
using std :: strncat ;
using std :: strncmp ;
using std :: strncpy ;
using std :: strpbrk ;
using std :: strrchr ;
using std :: strspn ;
using std :: strstr ;
using std :: strtok ;
using std :: strxfrm ;



extern "C" {
#59
extern int strerror_r ( int , char * , size_t ) ;





extern char * strtok_r ( char * , const char * ,
char * * ) ;




extern void * memccpy ( void * , const void * ,
int , size_t ) ;




extern int uucopy ( const void * , void * , size_t ) ;
extern int uucopystr ( const void * , void * , size_t ) ;
extern char * strsignal ( int ) ;
extern int ffs ( int ) ;
extern int strcasecmp ( const char * , const char * ) ;
extern int strncasecmp ( const char * , const char * , size_t ) ;
extern size_t strlcpy ( char * , const char * , size_t ) ;
extern size_t strlcat ( char * , const char * , size_t ) ;





extern char * strdup ( const char * ) ;
#128
}
#71 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstring"
namespace std
{


using :: memchr ;
using :: memcmp ;
using :: memcpy ;
using :: memmove ;
using :: memset ;
using :: strcat ;
using :: strcmp ;
using :: strcoll ;
using :: strcpy ;
using :: strcspn ;
using :: strerror ;
using :: strlen ;
using :: strncat ;
using :: strncmp ;
using :: strncpy ;
using :: strspn ;
using :: strtok ;
using :: strxfrm ;
using :: strchr ;
using :: strpbrk ;
using :: strrchr ;
using :: strstr ;
#121
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstdlib"
#39
#pragma GCC system_header
#1 "/usr/include/stdlib.h"
#15
#pragma ident "@(#)stdlib.h 1.52    12/08/01 SMI"
#1 "/usr/include/iso/stdlib_iso.h"
#28
#pragma ident "@(#)stdlib_iso.h 1.9 04/09/28 SMI"
#33
extern "C" {



extern unsigned char __ctype [ ] ;
#45
namespace std {


typedef struct {
int quot ;
int rem ;
} div_t ;

typedef struct {
long quot ;
long rem ;
} ldiv_t ;




typedef unsigned long size_t ;
#107
extern void abort ( void ) ;
extern int abs ( int ) ;
extern int atexit ( void ( * ) ( void ) ) ;
extern double atof ( const char * ) ;
extern int atoi ( const char * ) ;
extern long int atol ( const char * ) ;
extern void * bsearch ( const void * , const void * , size_t , size_t ,
int ( * ) ( const void * , const void * ) ) ;

extern "C++" {
void * bsearch ( const void * , const void * , size_t , size_t ,
int ( * ) ( const void * , const void * ) ) ;
}

extern void * calloc ( size_t , size_t ) ;
extern div_t div ( int , int ) ;
extern void exit ( int )
;
extern void free ( void * ) ;
extern char * getenv ( const char * ) ;
extern long int labs ( long ) ;
extern ldiv_t ldiv ( long , long ) ;
extern void * malloc ( size_t ) ;
extern int mblen ( const char * , size_t ) ;
extern size_t mbstowcs ( wchar_t * , const char * ,
size_t ) ;
extern int mbtowc ( wchar_t * , const char * , size_t ) ;
extern void qsort ( void * , size_t , size_t , int ( * ) ( const void * , const void * ) ) ;

extern "C++" {
void qsort ( void * , size_t , size_t , int ( * ) ( const void * , const void * ) ) ;
}

extern int rand ( void ) ;
extern void * realloc ( void * , size_t ) ;
extern void srand ( unsigned int ) ;
extern double strtod ( const char * , char * * ) ;
extern long int strtol ( const char * , char * * , int ) ;
extern unsigned long int strtoul ( const char * ,
char * * , int ) ;
extern int system ( const char * ) ;
extern int wctomb ( char * , wchar_t ) ;
extern size_t wcstombs ( char * , const wchar_t * ,
size_t ) ;


extern "C++" {
inline long abs ( long _l ) { return labs ( _l ) ; }
inline ldiv_t div ( long _l1 , long _l2 ) { return ldiv ( _l1 , _l2 ) ; }
}
#193
}



}
#1 "/usr/include/iso/stdlib_c99.h"
#20
#pragma ident "@(#)stdlib_c99.h 1.2 04/03/29 SMI"


extern "C" {
#35
typedef struct {
long long quot ;
long long rem ;
} lldiv_t ;
#46
extern void _Exit ( int ) ;
extern float strtof ( const char * , char * * ) ;
extern long double strtold ( const char * , char * * ) ;


extern long long atoll ( const char * ) ;
extern long long llabs ( long long ) ;
extern lldiv_t lldiv ( long long , long long ) ;
extern long long strtoll ( const char * , char * * ,
int ) ;
extern unsigned long long strtoull ( const char * ,
char * * , int ) ;
#83
}
#1 "/usr/include/sys/wait.h"
#16
#pragma ident "@(#)wait.h   1.23    04/06/03 SMI"
#1 "/usr/include/sys/resource.h"
#16
#pragma ident "@(#)resource.h   1.37    07/02/07 SMI"
#24
extern "C" {
#57
typedef unsigned long rlim_t ;
#106
struct rlimit {
rlim_t rlim_cur ;
rlim_t rlim_max ;
} ;




typedef u_longlong_t rlim64_t ;





struct rlimit64 {
rlim64_t rlim_cur ;
rlim64_t rlim_max ;
} ;
#145
struct rusage {
struct timeval ru_utime ;
struct timeval ru_stime ;
long ru_maxrss ;
long ru_ixrss ;
long ru_idrss ;
long ru_isrss ;
long ru_minflt ;
long ru_majflt ;
long ru_nswap ;
long ru_inblock ;
long ru_oublock ;
long ru_msgsnd ;
long ru_msgrcv ;
long ru_nsignals ;
long ru_nvcsw ;
long ru_nivcsw ;
} ;
#226
#pragma redefine_extname setrlimit64 setrlimit
#pragma redefine_extname getrlimit64 getrlimit
#237
extern int setrlimit ( int , const struct rlimit * ) ;
extern int getrlimit ( int , struct rlimit * ) ;




extern int setrlimit64 ( int , const struct rlimit64 * ) ;
extern int getrlimit64 ( int , struct rlimit64 * ) ;


extern int getpriority ( int , id_t ) ;
extern int setpriority ( int , id_t , int ) ;
extern int getrusage ( int , struct rusage * ) ;
#272
}
#1 "/usr/include/sys/siginfo.h"
#21
#pragma ident "@(#)siginfo.h    1.59    04/07/15 SMI"
#27
extern "C" {
#1 "/usr/include/sys/machsig.h"
#16
#pragma ident "@(#)machsig.h    1.11    03/09/26 SMI"
#21
extern "C" {
#1 "/usr/include/vm/faultcode.h"
#37
#pragma ident "@(#)faultcode.h  1.16    09/07/02 SMI"


extern "C" {
#63
typedef int faultcode_t ;

extern int fc_decode ( faultcode_t ) ;




}
#105 "/usr/include/sys/machsig.h"
}
#227 "/usr/include/sys/siginfo.h"
typedef struct siginfo {



int si_signo ;
int si_code ;
int si_errno ;

int si_pad ;

union {

int __pad [ ( ( 256 / sizeof ( int ) ) - 4 ) ] ;

struct {
pid_t __pid ;
union {
struct {
uid_t __uid ;


union sigval __value ;



} __kill ;
struct {
clock_t __utime ;
int __status ;
clock_t __stime ;
} __cld ;
} __pdata ;
ctid_t __ctid ;
zoneid_t __zoneid ;
} __proc ;

struct {
void * __addr ;
int __trapno ;
caddr_t __pc ;
} __fault ;

struct {

int __fd ;
long __band ;
} __file ;

struct {
caddr_t __faddr ;

timestruc_t __tstamp ;



short __syscall ;
char __nsysarg ;
char __fault ;
long __sysarg [ 8 ] ;
int __mstate [ 10 ] ;
} __prof ;

struct {
int32_t __entity ;
} __rctl ;
} __data ;

} siginfo_t ;
#369
typedef struct k_siginfo {
int si_signo ;
int si_code ;
int si_errno ;

int si_pad ;

union {
struct {
pid_t __pid ;
union {
struct {
uid_t __uid ;
union sigval __value ;
} __kill ;
struct {
clock_t __utime ;
int __status ;
clock_t __stime ;
} __cld ;
} __pdata ;
ctid_t __ctid ;
zoneid_t __zoneid ;
} __proc ;

struct {
void * __addr ;
int __trapno ;
caddr_t __pc ;
} __fault ;

struct {

int __fd ;
long __band ;
} __file ;

struct {
caddr_t __faddr ;


timestruc_t __tstamp ;



short __syscall ;
char __nsysarg ;
char __fault ;



} __prof ;

struct {
int32_t __entity ;
} __rctl ;

} __data ;

} k_siginfo_t ;

typedef struct sigqueue {
struct sigqueue * sq_next ;
k_siginfo_t sq_info ;
void ( * sq_func ) ( struct sigqueue * ) ;
void * sq_backptr ;

int sq_external ;
} sigqueue_t ;
#478
}
#1 "/usr/include/sys/procset.h"
#15
#pragma ident "@(#)procset.h    1.26    11/04/18 SMI"


extern "C" {
#1 "/usr/include/sys/signal.h"
#16
#pragma ident "@(#)signal.h 1.66    04/09/28 SMI"
#1 "/usr/include/sys/iso/signal_iso.h"
#28
#pragma ident "@(#)signal_iso.h 1.6 03/05/02 SMI"
#33
extern "C" {
#83
extern long _sysconf ( int ) ;





typedef void SIG_FUNC_TYP ( int ) ;
typedef SIG_FUNC_TYP * SIG_TYP ;
#126
}
#22 "/usr/include/sys/signal.h"
extern "C" {
#56
typedef struct {
unsigned int __sigbits [ 2 ] ;
} k_sigset_t ;
#74
struct sigaction {
int sa_flags ;
union {

void ( * _handler ) ( int ) ;
#85
void ( * _sigaction ) ( int , siginfo_t * , void * ) ;

} _funcptr ;
sigset_t sa_mask ;



} ;
#161
typedef struct sigaltstack {



void * ss_sp ;
size_t ss_size ;
int ss_flags ;
} stack_t ;
#190
typedef struct signotify_id {
pid_t sn_pid ;
int sn_index ;
int sn_pad ;
} signotify_id_t ;
#220
struct sigstack {
void * ss_sp ;
int ss_onstack ;
} ;
#1 "/usr/include/sys/ucontext.h"
#15
#pragma ident "@(#)ucontext.h   1.12    11/02/11 SMI"
#1 "/usr/include/sys/regset.h"
#15
#pragma ident "@(#)regset.h 1.12    11/08/26 SMI"
#24
extern "C" {
#141
typedef long greg_t ;
#153
typedef greg_t gregset_t [ 28 ] ;
#174
struct fnsave_state {
uint16_t f_fcw ;
uint16_t __f_ign0 ;
uint16_t f_fsw ;
uint16_t __f_ign1 ;
uint16_t f_ftw ;
uint16_t __f_ign2 ;
uint32_t f_eip ;
uint16_t f_cs ;
uint16_t f_fop ;
uint32_t f_dp ;
uint16_t f_ds ;
uint16_t __f_ign3 ;
union {
uint16_t fpr_16 [ 5 ] ;
} f_st [ 8 ] ;
} ;
#197
struct fxsave_state {
uint16_t fx_fcw ;
uint16_t fx_fsw ;
uint16_t fx_fctw ;
uint16_t fx_fop ;

uint64_t fx_rip ;
uint64_t fx_rdp ;
#213
uint32_t fx_mxcsr ;
uint32_t fx_mxcsr_mask ;
union {
uint16_t fpr_16 [ 5 ] ;
u_longlong_t fpr_mmx ;
uint32_t __fpr_pad [ 4 ] ;
} fx_st [ 8 ] ;

upad128_t fx_xmm [ 16 ] ;
upad128_t __fx_ign2 [ 6 ] ;




} ;





struct xsave_state {
struct fxsave_state xs_fxsave ;
uint64_t xs_xstate_bv ;
uint64_t xs_rsv_mbz [ 2 ] ;
uint64_t xs_reserved [ 5 ] ;
upad128_t xs_ymm [ 16 ] ;
} ;



typedef struct fpu {
union {
struct fpchip_state {
uint16_t cw ;
uint16_t sw ;
uint8_t fctw ;
uint8_t __fx_rsvd ;
uint16_t fop ;
uint64_t rip ;
uint64_t rdp ;
uint32_t mxcsr ;
uint32_t mxcsr_mask ;
union {
uint16_t fpr_16 [ 5 ] ;
upad128_t __fpr_pad ;
} st [ 8 ] ;
upad128_t xmm [ 16 ] ;
upad128_t __fx_ign2 [ 6 ] ;
uint32_t status ;
uint32_t xstatus ;
} fpchip_state ;
uint32_t f_fpregs [ 130 ] ;
} fp_reg_set ;
} fpregset_t ;
#341
typedef struct {
union _kfpu_u {
struct fxsave_state kfpu_fx ;



struct xsave_state kfpu_xs ;
} kfpu_u ;
uint32_t kfpu_status ;
uint32_t kfpu_xstatus ;
} kfpu_t ;
#359
typedef struct dbregset {
unsigned long debugreg [ 16 ] ;
} dbregset_t ;





typedef struct {
gregset_t gregs ;
fpregset_t fpregs ;
} mcontext_t ;
#487
typedef struct {
unsigned long xrs_id ;
caddr_t xrs_ptr ;
} xrs_t ;
#512
}
#1 "/usr/include/sys/signal.h"
#26 "/usr/include/sys/ucontext.h"
extern "C" {
#54
typedef struct ucontext ucontext_t ;





struct ucontext {



unsigned long uc_flags ;
ucontext_t * uc_link ;
sigset_t uc_sigmask ;
stack_t uc_stack ;
mcontext_t uc_mcontext ;

xrs_t uc_xrs ;



long uc_filler [ 3 ] ;
} ;
#137
}
#313 "/usr/include/sys/signal.h"
}
#41 "/usr/include/sys/procset.h"
typedef enum

idtype

{
P_PID ,
P_PPID ,
P_PGID ,

P_SID ,
P_CID ,
P_UID ,
P_GID ,
P_ALL ,
P_LWPID ,
P_TASKID ,
P_PROJID ,
P_POOLID ,
P_ZONEID ,
P_CTID ,
P_CPUID ,
P_PSETID
} idtype_t ;
#72
typedef enum idop {
POP_DIFF ,


POP_AND ,


POP_OR ,


POP_XOR


} idop_t ;
#93
typedef struct procset {
idop_t p_op ;




idtype_t p_lidtype ;


id_t p_lid ;

idtype_t p_ridtype ;


id_t p_rid ;
} procset_t ;
#138
}
#29 "/usr/include/sys/wait.h"
extern "C" {
#82
extern pid_t wait ( int * ) ;
extern pid_t waitpid ( pid_t , int * , int ) ;


extern int waitid ( idtype_t , id_t , siginfo_t * , int ) ;


extern pid_t wait3 ( int * , int , struct rusage * ) ;




extern pid_t wait4 ( pid_t , int * , int , struct rusage * ) ;
#117
}
#29 "/usr/include/stdlib.h"
using std :: div_t ;
using std :: ldiv_t ;
using std :: size_t ;
using std :: abort ;
using std :: abs ;
using std :: atexit ;
using std :: atof ;
using std :: atoi ;
using std :: atol ;
using std :: bsearch ;
using std :: calloc ;
using std :: div ;
using std :: exit ;
using std :: free ;
using std :: getenv ;
using std :: labs ;
using std :: ldiv ;
using std :: malloc ;
using std :: mblen ;
using std :: mbstowcs ;
using std :: mbtowc ;
using std :: qsort ;
using std :: rand ;
using std :: realloc ;
using std :: srand ;
using std :: strtod ;
using std :: strtol ;
using std :: strtoul ;
using std :: system ;
using std :: wcstombs ;
using std :: wctomb ;



extern "C" {
#92
#pragma redefine_extname mkstemp64 mkstemp
#102
extern int rand_r ( unsigned int * ) ;


extern void _exithandle ( void ) ;




extern double drand48 ( void ) ;
extern double erand48 ( unsigned short * ) ;
extern long jrand48 ( unsigned short * ) ;
extern void lcong48 ( unsigned short * ) ;
extern long lrand48 ( void ) ;
extern long mrand48 ( void ) ;
extern long nrand48 ( unsigned short * ) ;
extern unsigned short * seed48 ( unsigned short * ) ;
extern void srand48 ( long ) ;
extern int putenv ( char * ) ;
extern void setkey ( const char * ) ;
#149
extern int mkstemp ( char * ) ;




extern int mkstemp64 ( char * ) ;





extern long a64l ( const char * ) ;
extern char * ecvt ( double , int , int * , int * ) ;
extern char * fcvt ( double , int , int * , int * ) ;
extern char * gcvt ( double , int , char * ) ;
extern int getsubopt ( char * * , char * const * , char * * ) ;
extern int grantpt ( int ) ;
extern char * initstate ( unsigned , char * , size_t ) ;
extern char * l64a ( long ) ;
extern char * mktemp ( char * ) ;
extern char * ptsname ( int ) ;
extern long random ( void ) ;
extern char * realpath ( const char * , char * ) ;
extern char * setstate ( const char * ) ;
extern void srandom ( unsigned ) ;
extern int unlockpt ( int ) ;


extern int ttyslot ( void ) ;
extern void * valloc ( size_t ) ;
#185
extern int posix_openpt ( int ) ;
extern int setenv ( const char * , const char * , int ) ;
extern int unsetenv ( const char * ) ;




extern void closefrom ( int ) ;
extern int dup2 ( int , int ) ;
extern int fdwalk ( int ( * ) ( void * , int ) , void * ) ;
extern char * qecvt ( long double , int , int * , int * ) ;
extern char * qfcvt ( long double , int , int * , int * ) ;
extern char * qgcvt ( long double , int , char * ) ;
extern char * getcwd ( char * , size_t ) ;
extern const char * getexecname ( void ) ;
extern char * getlogin ( void ) ;
extern int getopt ( int , char * const * , const char * ) ;
extern char * optarg ;
extern int optind , opterr , optopt ;
extern char * getpass ( const char * ) ;
extern char * getpassphrase ( const char * ) ;
extern int getpw ( uid_t , char * ) ;
extern int isatty ( int ) ;
extern void * memalign ( size_t , size_t ) ;
extern char * ttyname ( int ) ;
extern char * mkdtemp ( char * ) ;


extern char * lltostr ( long long , char * ) ;
extern char * ulltostr ( unsigned long long , char * ) ;
#316
}
#114 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstdlib"
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 ;
#173
inline long long
abs ( long long __x ) { return __builtin_llabs ( __x ) ; }
#183
}
#196
namespace __gnu_cxx
{



using :: lldiv_t ;





using :: _Exit ;



using :: llabs ;

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

using :: lldiv ;
#228
using :: atoll ;
using :: strtoll ;
using :: strtoull ;

using :: strtof ;
using :: strtold ;


}

namespace std
{

using :: __gnu_cxx :: lldiv_t ;

using :: __gnu_cxx :: _Exit ;

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

using :: __gnu_cxx :: atoll ;
using :: __gnu_cxx :: strtof ;
using :: __gnu_cxx :: strtoll ;
using :: __gnu_cxx :: strtoull ;
using :: __gnu_cxx :: strtold ;
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cassert"
#41
#pragma GCC system_header
#1 "/usr/include/assert.h"
#16
#pragma ident "@(#)assert.h 1.10    04/05/18 SMI"


extern "C" {
#26
extern void __assert ( const char * , const char * , int ) ;
#33
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstdio"
#39
#pragma GCC system_header
#93
namespace std
{
using :: FILE ;
using :: fpos_t ;

using :: clearerr ;
using :: fclose ;
using :: feof ;
using :: ferror ;
using :: fflush ;
using :: fgetc ;
using :: fgetpos ;
using :: fgets ;
using :: fopen ;
using :: fprintf ;
using :: fputc ;
using :: fputs ;
using :: fread ;
using :: freopen ;
using :: fscanf ;
using :: fseek ;
using :: fsetpos ;
using :: ftell ;
using :: fwrite ;
using :: getc ;
using :: getchar ;
using :: gets ;
using :: perror ;
using :: printf ;
using :: putc ;
using :: putchar ;
using :: puts ;
using :: remove ;
using :: rename ;
using :: rewind ;
using :: scanf ;
using :: setbuf ;
using :: setvbuf ;
using :: sprintf ;
using :: sscanf ;
using :: tmpfile ;
using :: tmpnam ;
using :: ungetc ;
using :: vfprintf ;
using :: vprintf ;
using :: vsprintf ;
}
#149
namespace __gnu_cxx
{
#167
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 ;
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/climits"
#39
#pragma GCC system_header
#1 "/usr/include/limits.h"
#15
#pragma ident "@(#)limits.h 1.60    11/04/12 SMI"
#1 "/usr/include/iso/limits_iso.h"
#28
#pragma ident "@(#)limits_iso.h 1.2 03/12/04 SMI"


extern "C" {
#83
}
#1 "/usr/include/sys/int_limits.h"
#9
#pragma ident "@(#)int_limits.h 1.9 04/09/28 SMI"
#38
extern "C" {
#257
}
#35 "/usr/include/limits.h"
extern "C" {
#297
typedef unsigned long size_t ;





extern long _sysconf ( int ) ;
#313
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/string"
#36
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stringfwd.h"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/memoryfwd.h"
#46
#pragma GCC system_header
#50
namespace std
{
#63
template < typename >
class allocator ;

template < >
class allocator < void > ;


template < typename , typename >
struct uses_allocator ;




}
#42 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stringfwd.h"
namespace std
{
#52
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 ;





template < > struct char_traits < char16_t > ;
template < > struct char_traits < char32_t > ;


typedef basic_string < char16_t > u16string ;


typedef basic_string < char32_t > u32string ;





}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/char_traits.h"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_algobase.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/functexcept.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/exception_defines.h"
#42 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/functexcept.h"
namespace std
{



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


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


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

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


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

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

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

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

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

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

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

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

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


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

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

void
__throw_future_error ( int ) __attribute__ ( ( __noreturn__ ) ) ;


void
__throw_bad_function_call ( ) __attribute__ ( ( __noreturn__ ) ) ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/cpp_type_traits.h"
#35
#pragma GCC system_header
#68
namespace __gnu_cxx
{


template < typename _Iterator , typename _Container >
class __normal_iterator ;


}

namespace std
{


struct __true_type { } ;
struct __false_type { } ;

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

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



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


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

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


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

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




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




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

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

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

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


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



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

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


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

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

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

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

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

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

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

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




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


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

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

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




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

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




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

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




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




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




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




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

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


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


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

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

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

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




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


template < typename _Iterator >
class move_iterator ;

template < typename _Iterator >
struct __is_move_iterator < move_iterator < _Iterator > >
{
enum { __value = 1 } ;
typedef __true_type __type ;
} ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/type_traits.h"
#32
#pragma GCC system_header
#37
namespace __gnu_cxx
{



template < bool , typename >
struct __enable_if
{ } ;

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



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

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



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

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

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

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

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

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

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

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


template < >
struct __add_unsigned < bool > ;

template < >
struct __add_unsigned < wchar_t > ;



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

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

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

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

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

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

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

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


template < >
struct __remove_unsigned < bool > ;

template < >
struct __remove_unsigned < wchar_t > ;



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

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



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




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

template < >
struct __promote < long double >
{ typedef long double __type ; } ;

template < >
struct __promote < double >
{ typedef double __type ; } ;

template < >
struct __promote < float >
{ typedef float __type ; } ;

template < typename _Tp , typename _Up ,
typename _Tp2 = typename __promote < _Tp > :: __type ,
typename _Up2 = typename __promote < _Up > :: __type >
struct __promote_2
{
typedef __typeof__ ( _Tp2 ( ) + _Up2 ( ) ) __type ;
} ;

template < typename _Tp , typename _Up , typename _Vp ,
typename _Tp2 = typename __promote < _Tp > :: __type ,
typename _Up2 = typename __promote < _Up > :: __type ,
typename _Vp2 = typename __promote < _Vp > :: __type >
struct __promote_3
{
typedef __typeof__ ( _Tp2 ( ) + _Up2 ( ) + _Vp2 ( ) ) __type ;
} ;

template < typename _Tp , typename _Up , typename _Vp , typename _Wp ,
typename _Tp2 = typename __promote < _Tp > :: __type ,
typename _Up2 = typename __promote < _Up > :: __type ,
typename _Vp2 = typename __promote < _Vp > :: __type ,
typename _Wp2 = typename __promote < _Wp > :: __type >
struct __promote_4
{
typedef __typeof__ ( _Tp2 ( ) + _Up2 ( ) + _Vp2 ( ) + _Wp2 ( ) ) __type ;
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/numeric_traits.h"
#32
#pragma GCC system_header
#37
namespace __gnu_cxx
{
#54
template < typename _Value >
struct __numeric_traits_integer
{

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



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

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

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

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

template < typename _Value >
const int __numeric_traits_integer < _Value > :: __digits ;
#99
template < typename _Value >
struct __numeric_traits_floating
{

static const int __max_digits10 = ( 2 + ( std :: __are_same < _Value , float > :: __value ? 24 : std :: __are_same < _Value
#103
, double > :: __value ? 53 : 64 ) * 643L / 2136 ) ;


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

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

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

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

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

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


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_iterator_base_types.h"
#62
#pragma GCC system_header
#70
namespace std
{
#89
struct input_iterator_tag { } ;


struct output_iterator_tag { } ;


struct forward_iterator_tag : public input_iterator_tag { } ;



struct bidirectional_iterator_tag : public forward_iterator_tag { } ;



struct random_access_iterator_tag : public bidirectional_iterator_tag { } ;
#116
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 ;
} ;
#142
template < typename _Tp > class __has_iterator_category_helper : __sfinae_types { template < typename _Up > struct _Wrap_type
#142
{ } ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: iterator_category > * ) ; template < typename
#142
_Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) == 1 ; } ; template
#142
< typename _Tp > struct __has_iterator_category : integral_constant < bool , __has_iterator_category_helper < typename remove_cv
#142
< _Tp > :: type > :: value > { } ;

template < typename _Iterator ,
bool = __has_iterator_category < _Iterator > :: value >
struct __iterator_traits { } ;

template < typename _Iterator >
struct __iterator_traits < _Iterator , true >
{
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 _Iterator >
struct iterator_traits
: public __iterator_traits < _Iterator > { } ;
#174
template < typename _Tp >
struct iterator_traits < _Tp * >
{
typedef random_access_iterator_tag iterator_category ;
typedef _Tp value_type ;
typedef ptrdiff_t difference_type ;
typedef _Tp * pointer ;
typedef _Tp & reference ;
} ;


template < typename _Tp >
struct iterator_traits < const _Tp * >
{
typedef random_access_iterator_tag iterator_category ;
typedef _Tp value_type ;
typedef ptrdiff_t difference_type ;
typedef const _Tp * pointer ;
typedef const _Tp & reference ;
} ;





template < typename _Iter >
inline typename iterator_traits < _Iter > :: iterator_category
__iterator_category ( const _Iter & )
{ return typename iterator_traits < _Iter > :: iterator_category ( ) ; }





template < typename _Iterator , bool _HasBase >
struct _Iter_base
{
typedef _Iterator iterator_type ;
static iterator_type _S_base ( _Iterator __it )
{ return __it ; }
} ;

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


template < typename _InIter >
using _RequireInputIter = typename
enable_if < is_convertible < typename
iterator_traits < _InIter > :: iterator_category ,
input_iterator_tag > :: value > :: type ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_iterator_base_funcs.h"
#62
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/debug/debug.h"
#46
namespace std
{
namespace __debug { }
}




namespace __gnu_debug
{
using namespace std :: __debug ;
}
#67 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_iterator_base_funcs.h"
namespace std
{


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



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

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



return __last - __first ;
}
#112
template < typename _InputIterator >
inline typename iterator_traits < _InputIterator > :: difference_type
distance ( _InputIterator __first , _InputIterator __last )
{

return std :: __distance ( __first , __last ,
std :: __iterator_category ( __first ) ) ;
}

template < typename _InputIterator , typename _Distance >
inline void
__advance ( _InputIterator & __i , _Distance __n , input_iterator_tag )
{


;
while ( __n -- )
++ __i ;
}

template < typename _BidirectionalIterator , typename _Distance >
inline void
__advance ( _BidirectionalIterator & __i , _Distance __n ,
bidirectional_iterator_tag )
{



if ( __n > 0 )
while ( __n -- )
++ __i ;
else
while ( __n ++ )
-- __i ;
}

template < typename _RandomAccessIterator , typename _Distance >
inline void
__advance ( _RandomAccessIterator & __i , _Distance __n ,
random_access_iterator_tag )
{



__i += __n ;
}
#171
template < typename _InputIterator , typename _Distance >
inline void
advance ( _InputIterator & __i , _Distance __n )
{

typename iterator_traits < _InputIterator > :: difference_type __d = __n ;
std :: __advance ( __i , __d , std :: __iterator_category ( __i ) ) ;
}



template < typename _ForwardIterator >
inline _ForwardIterator
next ( _ForwardIterator __x , typename
iterator_traits < _ForwardIterator > :: difference_type __n = 1 )
{
std :: advance ( __x , __n ) ;
return __x ;
}

template < typename _BidirectionalIterator >
inline _BidirectionalIterator
prev ( _BidirectionalIterator __x , typename
iterator_traits < _BidirectionalIterator > :: difference_type __n = 1 )
{
std :: advance ( __x , - __n ) ;
return __x ;
}




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_iterator.h"
#67
namespace std
{
#95
template < typename _Iterator >
class reverse_iterator
: public iterator < typename iterator_traits < _Iterator > :: iterator_category ,
typename iterator_traits < _Iterator > :: value_type ,
typename iterator_traits < _Iterator > :: difference_type ,
typename iterator_traits < _Iterator > :: pointer ,
typename iterator_traits < _Iterator > :: reference >
{
protected :
_Iterator current ;

typedef iterator_traits < _Iterator > __traits_type ;

public :
typedef _Iterator iterator_type ;
typedef typename __traits_type :: difference_type difference_type ;
typedef typename __traits_type :: pointer pointer ;
typedef typename __traits_type :: reference reference ;
#120
reverse_iterator ( ) : current ( ) { }




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




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





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




iterator_type
base ( ) const
{ return current ; }
#159
reference
operator * ( ) const
{
_Iterator __tmp = current ;
return * -- __tmp ;
}
#171
pointer
operator -> ( ) const
{ return & ( operator * ( ) ) ; }
#180
reverse_iterator &
operator ++ ( )
{
-- current ;
return * this ;
}
#192
reverse_iterator
operator ++ ( int )
{
reverse_iterator __tmp = * this ;
-- current ;
return __tmp ;
}
#205
reverse_iterator &
operator -- ( )
{
++ current ;
return * this ;
}
#217
reverse_iterator
operator -- ( int )
{
reverse_iterator __tmp = * this ;
++ current ;
return __tmp ;
}
#230
reverse_iterator
operator + ( difference_type __n ) const
{ return reverse_iterator ( current - __n ) ; }
#240
reverse_iterator &
operator += ( difference_type __n )
{
current -= __n ;
return * this ;
}
#252
reverse_iterator
operator - ( difference_type __n ) const
{ return reverse_iterator ( current + __n ) ; }
#262
reverse_iterator &
operator -= ( difference_type __n )
{
current += __n ;
return * this ;
}
#274
reference
operator [ ] ( difference_type __n ) const
{ return * ( * this + __n ) ; }
} ;
#289
template < typename _Iterator >
inline bool
operator == ( const reverse_iterator < _Iterator > & __x ,
const reverse_iterator < _Iterator > & __y )
{ return __x . base ( ) == __y . base ( ) ; }

template < typename _Iterator >
inline bool
operator < ( const reverse_iterator < _Iterator > & __x ,
const reverse_iterator < _Iterator > & __y )
{ return __y . base ( ) < __x . base ( ) ; }

template < typename _Iterator >
inline bool
operator != ( const reverse_iterator < _Iterator > & __x ,
const reverse_iterator < _Iterator > & __y )
{ return ! ( __x == __y ) ; }

template < typename _Iterator >
inline bool
operator > ( const reverse_iterator < _Iterator > & __x ,
const reverse_iterator < _Iterator > & __y )
{ return __y < __x ; }

template < typename _Iterator >
inline bool
operator <= ( const reverse_iterator < _Iterator > & __x ,
const reverse_iterator < _Iterator > & __y )
{ return ! ( __y < __x ) ; }

template < typename _Iterator >
inline bool
operator >= ( const reverse_iterator < _Iterator > & __x ,
const reverse_iterator < _Iterator > & __y )
{ return ! ( __x < __y ) ; }

template < typename _Iterator >
inline typename reverse_iterator < _Iterator > :: difference_type
operator - ( const reverse_iterator < _Iterator > & __x ,
const reverse_iterator < _Iterator > & __y )
{ return __y . base ( ) - __x . base ( ) ; }

template < typename _Iterator >
inline reverse_iterator < _Iterator >
operator + ( typename reverse_iterator < _Iterator > :: difference_type __n ,
const reverse_iterator < _Iterator > & __x )
{ return reverse_iterator < _Iterator > ( __x . base ( ) - __n ) ; }



template < typename _IteratorL , typename _IteratorR >
inline bool
operator == ( const reverse_iterator < _IteratorL > & __x ,
const reverse_iterator < _IteratorR > & __y )
{ return __x . base ( ) == __y . base ( ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator < ( const reverse_iterator < _IteratorL > & __x ,
const reverse_iterator < _IteratorR > & __y )
{ return __y . base ( ) < __x . base ( ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator != ( const reverse_iterator < _IteratorL > & __x ,
const reverse_iterator < _IteratorR > & __y )
{ return ! ( __x == __y ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator > ( const reverse_iterator < _IteratorL > & __x ,
const reverse_iterator < _IteratorR > & __y )
{ return __y < __x ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator <= ( const reverse_iterator < _IteratorL > & __x ,
const reverse_iterator < _IteratorR > & __y )
{ return ! ( __y < __x ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator >= ( const reverse_iterator < _IteratorL > & __x ,
const reverse_iterator < _IteratorR > & __y )
{ return ! ( __x < __y ) ; }

template < typename _IteratorL , typename _IteratorR >


inline auto
operator - ( const reverse_iterator < _IteratorL > & __x ,
const reverse_iterator < _IteratorR > & __y )
-> decltype ( __y . base ( ) - __x . base ( ) )





{ return __y . base ( ) - __x . base ( ) ; }
#401
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 ) { }
#435
back_insert_iterator &
operator = ( const typename _Container :: value_type & __value )
{
container -> push_back ( __value ) ;
return * this ;
}

back_insert_iterator &
operator = ( typename _Container :: value_type && __value )
{
container -> push_back ( std :: move ( __value ) ) ;
return * this ;
}



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


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


back_insert_iterator
operator ++ ( int )
{ return * this ; }
} ;
#477
template < typename _Container >
inline back_insert_iterator < _Container >
back_inserter ( _Container & __x )
{ return back_insert_iterator < _Container > ( __x ) ; }
#492
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 ) { }
#525
front_insert_iterator &
operator = ( const typename _Container :: value_type & __value )
{
container -> push_front ( __value ) ;
return * this ;
}

front_insert_iterator &
operator = ( typename _Container :: value_type && __value )
{
container -> push_front ( std :: move ( __value ) ) ;
return * this ;
}



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


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


front_insert_iterator
operator ++ ( int )
{ return * this ; }
} ;
#567
template < typename _Container >
inline front_insert_iterator < _Container >
front_inserter ( _Container & __x )
{ return front_insert_iterator < _Container > ( __x ) ; }
#586
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 ) { }
#637
insert_iterator &
operator = ( const typename _Container :: value_type & __value )
{
iter = container -> insert ( iter , __value ) ;
++ iter ;
return * this ;
}

insert_iterator &
operator = ( typename _Container :: value_type && __value )
{
iter = container -> insert ( iter , std :: move ( __value ) ) ;
++ iter ;
return * this ;
}



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


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


insert_iterator &
operator ++ ( int )
{ return * this ; }
} ;
#681
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
{
#705
using std :: iterator_traits ;
using std :: iterator ;
template < typename _Iterator , typename _Container >
class __normal_iterator
{
protected :
_Iterator _M_current ;

typedef iterator_traits < _Iterator > __traits_type ;

public :
typedef _Iterator iterator_type ;
typedef typename __traits_type :: iterator_category iterator_category ;
typedef typename __traits_type :: value_type value_type ;
typedef typename __traits_type :: difference_type difference_type ;
typedef typename __traits_type :: reference reference ;
typedef typename __traits_type :: pointer pointer ;

constexpr __normal_iterator ( ) : _M_current ( _Iterator ( ) ) { }

explicit
__normal_iterator ( const _Iterator & __i ) : _M_current ( __i ) { }


template < typename _Iter >
__normal_iterator ( const __normal_iterator < _Iter ,
typename __enable_if <
( std :: __are_same < _Iter , typename _Container :: pointer > :: __value ) ,
_Container > :: __type > & __i )
: _M_current ( __i . base ( ) ) { }


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

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

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

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


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

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


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

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

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

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

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

const _Iterator &
base ( ) const
{ return _M_current ; }
} ;
#803
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 auto
operator - ( const __normal_iterator < _IteratorL , _Container > & __lhs ,
const __normal_iterator < _IteratorR , _Container > & __rhs )
-> decltype ( __lhs . base ( ) - __rhs . base ( ) )





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

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

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


}



namespace std
{
#929
template < typename _Iterator >
class move_iterator
{
protected :
_Iterator _M_current ;

typedef iterator_traits < _Iterator > __traits_type ;

public :
typedef _Iterator iterator_type ;
typedef typename __traits_type :: iterator_category iterator_category ;
typedef typename __traits_type :: value_type value_type ;
typedef typename __traits_type :: difference_type difference_type ;

typedef _Iterator pointer ;
typedef value_type && reference ;

move_iterator ( )
: _M_current ( ) { }

explicit
move_iterator ( iterator_type __i )
: _M_current ( __i ) { }

template < typename _Iter >
move_iterator ( const move_iterator < _Iter > & __i )
: _M_current ( __i . base ( ) ) { }

iterator_type
base ( ) const
{ return _M_current ; }

reference
operator * ( ) const
{ return std :: move ( * _M_current ) ; }

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

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

move_iterator
operator ++ ( int )
{
move_iterator __tmp = * this ;
++ _M_current ;
return __tmp ;
}

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

move_iterator
operator -- ( int )
{
move_iterator __tmp = * this ;
-- _M_current ;
return __tmp ;
}

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

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

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

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

reference
operator [ ] ( difference_type __n ) const
{ return std :: move ( _M_current [ __n ] ) ; }
} ;




template < typename _IteratorL , typename _IteratorR >
inline bool
operator == ( const move_iterator < _IteratorL > & __x ,
const move_iterator < _IteratorR > & __y )
{ return __x . base ( ) == __y . base ( ) ; }

template < typename _Iterator >
inline bool
operator == ( const move_iterator < _Iterator > & __x ,
const move_iterator < _Iterator > & __y )
{ return __x . base ( ) == __y . base ( ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator != ( const move_iterator < _IteratorL > & __x ,
const move_iterator < _IteratorR > & __y )
{ return ! ( __x == __y ) ; }

template < typename _Iterator >
inline bool
operator != ( const move_iterator < _Iterator > & __x ,
const move_iterator < _Iterator > & __y )
{ return ! ( __x == __y ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator < ( const move_iterator < _IteratorL > & __x ,
const move_iterator < _IteratorR > & __y )
{ return __x . base ( ) < __y . base ( ) ; }

template < typename _Iterator >
inline bool
operator < ( const move_iterator < _Iterator > & __x ,
const move_iterator < _Iterator > & __y )
{ return __x . base ( ) < __y . base ( ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator <= ( const move_iterator < _IteratorL > & __x ,
const move_iterator < _IteratorR > & __y )
{ return ! ( __y < __x ) ; }

template < typename _Iterator >
inline bool
operator <= ( const move_iterator < _Iterator > & __x ,
const move_iterator < _Iterator > & __y )
{ return ! ( __y < __x ) ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator > ( const move_iterator < _IteratorL > & __x ,
const move_iterator < _IteratorR > & __y )
{ return __y < __x ; }

template < typename _Iterator >
inline bool
operator > ( const move_iterator < _Iterator > & __x ,
const move_iterator < _Iterator > & __y )
{ return __y < __x ; }

template < typename _IteratorL , typename _IteratorR >
inline bool
operator >= ( const move_iterator < _IteratorL > & __x ,
const move_iterator < _IteratorR > & __y )
{ return ! ( __x < __y ) ; }

template < typename _Iterator >
inline bool
operator >= ( const move_iterator < _Iterator > & __x ,
const move_iterator < _Iterator > & __y )
{ return ! ( __x < __y ) ; }


template < typename _IteratorL , typename _IteratorR >
inline auto
operator - ( const move_iterator < _IteratorL > & __x ,
const move_iterator < _IteratorR > & __y )
-> decltype ( __x . base ( ) - __y . base ( ) )
{ return __x . base ( ) - __y . base ( ) ; }

template < typename _Iterator >
inline auto
operator - ( const move_iterator < _Iterator > & __x ,
const move_iterator < _Iterator > & __y )
-> decltype ( __x . base ( ) - __y . base ( ) )
{ return __x . base ( ) - __y . base ( ) ; }

template < typename _Iterator >
inline move_iterator < _Iterator >
operator + ( typename move_iterator < _Iterator > :: difference_type __n ,
const move_iterator < _Iterator > & __x )
{ return __x + __n ; }

template < typename _Iterator >
inline move_iterator < _Iterator >
make_move_iterator ( _Iterator __i )
{ return move_iterator < _Iterator > ( __i ) ; }

template < typename _Iterator , typename _ReturnType
= typename conditional < __move_if_noexcept_cond
< typename iterator_traits < _Iterator > :: value_type > :: value ,
_Iterator , move_iterator < _Iterator >> :: type >
inline _ReturnType
__make_move_if_noexcept_iterator ( _Iterator __i )
{ return _ReturnType ( __i ) ; }




}
#72 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_algobase.h"
namespace std
{
#117
template < typename _ForwardIterator1 , typename _ForwardIterator2 >
inline void
iter_swap ( _ForwardIterator1 __a , _ForwardIterator2 __b )
{
#147
swap ( * __a , * __b ) ;

}
#163
template < typename _ForwardIterator1 , typename _ForwardIterator2 >
_ForwardIterator2
swap_ranges ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 )
{





;

for ( ; __first1 != __last1 ; ++ __first1 , ++ __first2 )
std :: iter_swap ( __first1 , __first2 ) ;
return __first2 ;
}
#191
template < typename _Tp >
inline const _Tp &
min ( const _Tp & __a , const _Tp & __b )
{



if ( __b < __a )
return __b ;
return __a ;
}
#214
template < typename _Tp >
inline const _Tp &
max ( const _Tp & __a , const _Tp & __b )
{



if ( __a < __b )
return __b ;
return __a ;
}
#237
template < typename _Tp , typename _Compare >
inline const _Tp &
min ( const _Tp & __a , const _Tp & __b , _Compare __comp )
{

if ( __comp ( __b , __a ) )
return __b ;
return __a ;
}
#258
template < typename _Tp , typename _Compare >
inline const _Tp &
max ( const _Tp & __a , const _Tp & __b , _Compare __comp )
{

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



template < typename _Iterator >
struct _Niter_base
: _Iter_base < _Iterator , __is_normal_iterator < _Iterator > :: __value >
{ } ;

template < typename _Iterator >
inline typename _Niter_base < _Iterator > :: iterator_type
__niter_base ( _Iterator __it )
{ return std :: _Niter_base < _Iterator > :: _S_base ( __it ) ; }


template < typename _Iterator >
struct _Miter_base
: _Iter_base < _Iterator , __is_move_iterator < _Iterator > :: __value >
{ } ;

template < typename _Iterator >
inline typename _Miter_base < _Iterator > :: iterator_type
__miter_base ( _Iterator __it )
{ return std :: _Miter_base < _Iterator > :: _S_base ( __it ) ; }
#297
template < bool , bool , typename >
struct __copy_move
{
template < typename _II , typename _OI >
static _OI
__copy_m ( _II __first , _II __last , _OI __result )
{
for ( ; __first != __last ; ++ __result , ++ __first )
* __result = * __first ;
return __result ;
}
} ;


template < typename _Category >
struct __copy_move < true , false , _Category >
{
template < typename _II , typename _OI >
static _OI
__copy_m ( _II __first , _II __last , _OI __result )
{
for ( ; __first != __last ; ++ __result , ++ __first )
* __result = std :: move ( * __first ) ;
return __result ;
}
} ;


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


template < >
struct __copy_move < true , false , random_access_iterator_tag >
{
template < typename _II , typename _OI >
static _OI
__copy_m ( _II __first , _II __last , _OI __result )
{
typedef typename iterator_traits < _II > :: difference_type _Distance ;
for ( _Distance __n = __last - __first ; __n > 0 ; -- __n )
{
* __result = std :: move ( * __first ) ;
++ __first ;
++ __result ;
}
return __result ;
}
} ;


template < bool _IsMove >
struct __copy_move < _IsMove , true , random_access_iterator_tag >
{
template < typename _Tp >
static _Tp *
__copy_m ( const _Tp * __first , const _Tp * __last , _Tp * __result )
{
const ptrdiff_t _Num = __last - __first ;
if ( _Num )
__builtin_memmove ( __result , __first , sizeof ( _Tp ) * _Num ) ;
return __result + _Num ;
}
} ;

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

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



template < typename _CharT >
struct char_traits ;

template < typename _CharT , typename _Traits >
class istreambuf_iterator ;

template < typename _CharT , typename _Traits >
class ostreambuf_iterator ;

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

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

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

template < bool _IsMove , typename _II , typename _OI >
inline _OI
__copy_move_a2 ( _II __first , _II __last , _OI __result )
{
return _OI ( std :: __copy_move_a < _IsMove > ( std :: __niter_base ( __first ) ,
std :: __niter_base ( __last ) ,
std :: __niter_base ( __result ) ) ) ;
}
#448
template < typename _II , typename _OI >
inline _OI
copy ( _II __first , _II __last , _OI __result )
{




;

return ( std :: __copy_move_a2 < __is_move_iterator < _II > :: __value >
( std :: __miter_base ( __first ) , std :: __miter_base ( __last ) ,
__result ) ) ;
}
#481
template < typename _II , typename _OI >
inline _OI
move ( _II __first , _II __last , _OI __result )
{




;

return std :: __copy_move_a2 < true > ( std :: __miter_base ( __first ) ,
std :: __miter_base ( __last ) , __result ) ;
}
#500
template < bool , bool , typename >
struct __copy_move_backward
{
template < typename _BI1 , typename _BI2 >
static _BI2
__copy_move_b ( _BI1 __first , _BI1 __last , _BI2 __result )
{
while ( __first != __last )
* -- __result = * -- __last ;
return __result ;
}
} ;


template < typename _Category >
struct __copy_move_backward < true , false , _Category >
{
template < typename _BI1 , typename _BI2 >
static _BI2
__copy_move_b ( _BI1 __first , _BI1 __last , _BI2 __result )
{
while ( __first != __last )
* -- __result = std :: move ( * -- __last ) ;
return __result ;
}
} ;


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


template < >
struct __copy_move_backward < true , false , random_access_iterator_tag >
{
template < typename _BI1 , typename _BI2 >
static _BI2
__copy_move_b ( _BI1 __first , _BI1 __last , _BI2 __result )
{
typename iterator_traits < _BI1 > :: difference_type __n ;
for ( __n = __last - __first ; __n > 0 ; -- __n )
* -- __result = std :: move ( * -- __last ) ;
return __result ;
}
} ;


template < bool _IsMove >
struct __copy_move_backward < _IsMove , true , random_access_iterator_tag >
{
template < typename _Tp >
static _Tp *
__copy_move_b ( const _Tp * __first , const _Tp * __last , _Tp * __result )
{
const ptrdiff_t _Num = __last - __first ;
if ( _Num )
__builtin_memmove ( __result - _Num , __first , sizeof ( _Tp ) * _Num ) ;
return __result - _Num ;
}
} ;

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

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

template < bool _IsMove , typename _BI1 , typename _BI2 >
inline _BI2
__copy_move_backward_a2 ( _BI1 __first , _BI1 __last , _BI2 __result )
{
return _BI2 ( std :: __copy_move_backward_a < _IsMove >
( std :: __niter_base ( __first ) , std :: __niter_base ( __last ) ,
std :: __niter_base ( __result ) ) ) ;
}
#617
template < typename _BI1 , typename _BI2 >
inline _BI2
copy_backward ( _BI1 __first , _BI1 __last , _BI2 __result )
{
#627
;

return ( std :: __copy_move_backward_a2 < __is_move_iterator < _BI1 > :: __value >
( std :: __miter_base ( __first ) , std :: __miter_base ( __last ) ,
__result ) ) ;
}
#653
template < typename _BI1 , typename _BI2 >
inline _BI2
move_backward ( _BI1 __first , _BI1 __last , _BI2 __result )
{
#663
;

return std :: __copy_move_backward_a2 < true > ( std :: __miter_base ( __first ) ,
std :: __miter_base ( __last ) ,
__result ) ;
}
#675
template < typename _ForwardIterator , typename _Tp >
inline typename
__gnu_cxx :: __enable_if < ! __is_scalar < _Tp > :: __value , void > :: __type
__fill_a ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __value )
{
for ( ; __first != __last ; ++ __first )
* __first = __value ;
}

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


template < typename _Tp >
inline typename
__gnu_cxx :: __enable_if < __is_byte < _Tp > :: __value , void > :: __type
__fill_a ( _Tp * __first , _Tp * __last , const _Tp & __c )
{
const _Tp __tmp = __c ;
__builtin_memset ( __first , static_cast < unsigned char > ( __tmp ) ,
__last - __first ) ;
}
#719
template < typename _ForwardIterator , typename _Tp >
inline void
fill ( _ForwardIterator __first , _ForwardIterator __last , const _Tp & __value )
{



;

std :: __fill_a ( std :: __niter_base ( __first ) , std :: __niter_base ( __last ) ,
__value ) ;
}

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

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

template < typename _Size , typename _Tp >
inline typename
__gnu_cxx :: __enable_if < __is_byte < _Tp > :: __value , _Tp * > :: __type
__fill_n_a ( _Tp * __first , _Size __n , const _Tp & __c )
{
std :: __fill_a ( __first , __first + __n , __c ) ;
return __first + __n ;
}
#779
template < typename _OI , typename _Size , typename _Tp >
inline _OI
fill_n ( _OI __first , _Size __n , const _Tp & __value )
{



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

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

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

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

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


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

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

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

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

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

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

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

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

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

return std :: __lexicographical_compare < __simple > :: __lc ( __first1 , __last1 ,
__first2 , __last2 ) ;
}
#941
template < typename _ForwardIterator , typename _Tp >
_ForwardIterator
lower_bound ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val )
{




typedef typename iterator_traits < _ForwardIterator > :: difference_type
_DistanceType ;




;

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

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



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

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

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

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

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

inline constexpr unsigned long long
__lg ( unsigned long long __n )
{ return sizeof ( long long ) * 8 - 1 - __builtin_clzll ( __n ) ; }
#1019
template < typename _II1 , typename _II2 >
inline bool
equal ( _II1 __first1 , _II1 __last1 , _II2 __first2 )
{
#1029
;

return std :: __equal_aux ( std :: __niter_base ( __first1 ) ,
std :: __niter_base ( __last1 ) ,
std :: __niter_base ( __first2 ) ) ;
}
#1051
template < typename _IIter1 , typename _IIter2 , typename _BinaryPredicate >
inline bool
equal ( _IIter1 __first1 , _IIter1 __last1 ,
_IIter2 __first2 , _BinaryPredicate __binary_pred )
{



;

for ( ; __first1 != __last1 ; ++ __first1 , ++ __first2 )
if ( ! bool ( __binary_pred ( * __first1 , * __first2 ) ) )
return false ;
return true ;
}
#1082
template < typename _II1 , typename _II2 >
inline bool
lexicographical_compare ( _II1 __first1 , _II1 __last1 ,
_II2 __first2 , _II2 __last2 )
{
#1096
;
;

return std :: __lexicographical_compare_aux ( std :: __niter_base ( __first1 ) ,
std :: __niter_base ( __last1 ) ,
std :: __niter_base ( __first2 ) ,
std :: __niter_base ( __last2 ) ) ;
}
#1118
template < typename _II1 , typename _II2 , typename _Compare >
bool
lexicographical_compare ( _II1 __first1 , _II1 __last1 ,
_II2 __first2 , _II2 __last2 , _Compare __comp )
{
typedef typename iterator_traits < _II1 > :: iterator_category _Category1 ;
typedef typename iterator_traits < _II2 > :: iterator_category _Category2 ;
typedef std :: __lc_rai < _Category1 , _Category2 > __rai_type ;




;
;

__last1 = __rai_type :: __newlast1 ( __first1 , __last1 , __first2 , __last2 ) ;
for ( ; __first1 != __last1 && __rai_type :: __cnd2 ( __first2 , __last2 ) ;
++ __first1 , ++ __first2 )
{
if ( __comp ( * __first1 , * __first2 ) )
return true ;
if ( __comp ( * __first2 , * __first1 ) )
return false ;
}
return __first1 == __last1 && __first2 != __last2 ;
}
#1158
template < typename _InputIterator1 , typename _InputIterator2 >
pair < _InputIterator1 , _InputIterator2 >
mismatch ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 )
{
#1169
;

while ( __first1 != __last1 && * __first1 == * __first2 )
{
++ __first1 ;
++ __first2 ;
}
return pair < _InputIterator1 , _InputIterator2 > ( __first1 , __first2 ) ;
}
#1195
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _BinaryPredicate >
pair < _InputIterator1 , _InputIterator2 >
mismatch ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _BinaryPredicate __binary_pred )
{



;

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


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/postypes.h"
#38
#pragma GCC system_header
#68
namespace std
{
#88
typedef long streamoff ;
#98
typedef ptrdiff_t streamsize ;
#111
template < typename _StateT >
class fpos
{
private :
streamoff _M_off ;
_StateT _M_state ;

public :




fpos ( )
: _M_off ( 0 ) , _M_state ( ) { }
#133
fpos ( streamoff __off )
: _M_off ( __off ) , _M_state ( ) { }


operator streamoff ( ) const { return _M_off ; }


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


_StateT
state ( ) const
{ return _M_state ; }





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





fpos &
operator -= ( streamoff __off )
{
_M_off -= __off ;
return * this ;
}
#177
fpos
operator + ( streamoff __off ) const
{
fpos __pos ( * this ) ;
__pos += __off ;
return __pos ;
}
#191
fpos
operator - ( streamoff __off ) const
{
fpos __pos ( * this ) ;
__pos -= __off ;
return __pos ;
}
#204
streamoff
operator - ( const fpos & __other ) const
{ return _M_off - __other . _M_off ; }
} ;
#214
template < typename _StateT >
inline bool
operator == ( const fpos < _StateT > & __lhs , const fpos < _StateT > & __rhs )
{ return streamoff ( __lhs ) == streamoff ( __rhs ) ; }

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





typedef fpos < mbstate_t > streampos ;

typedef fpos < mbstate_t > wstreampos ;



typedef fpos < mbstate_t > u16streampos ;

typedef fpos < mbstate_t > u32streampos ;



}
#43 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/char_traits.h"
namespace __gnu_cxx
{
#57
template < typename _CharT >
struct _Char_types
{
typedef unsigned long int_type ;
typedef std :: streampos pos_type ;
typedef std :: streamoff off_type ;
typedef std :: mbstate_t state_type ;
} ;
#82
template < typename _CharT >
struct char_traits
{
typedef _CharT char_type ;
typedef typename _Char_types < _CharT > :: int_type int_type ;
typedef typename _Char_types < _CharT > :: pos_type pos_type ;
typedef typename _Char_types < _CharT > :: off_type off_type ;
typedef typename _Char_types < _CharT > :: state_type state_type ;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


}

namespace std
{
#226
template < class _CharT >
struct char_traits : public __gnu_cxx :: char_traits < _CharT >
{ } ;



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

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

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

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

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

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

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

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

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

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

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



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

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

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

static constexpr int_type
not_eof ( const int_type & __c ) noexcept
{ 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 ) noexcept
{ __c1 = __c2 ; }

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

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

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

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

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

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

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

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

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

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

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

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

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



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstdint"
#32
#pragma GCC system_header
#1 "/usr/include/stdint.h"
#9
#pragma ident "@(#)stdint.h 1.1 03/12/04 SMI"
#1 "/usr/include/sys/stdint.h"
#9
#pragma ident "@(#)stdint.h 1.1 03/12/04 SMI"
#1 "/usr/include/sys/int_const.h"
#9
#pragma ident "@(#)int_const.h  1.5 04/09/28 SMI"
#36
extern "C" {
#111
}
#46 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cstdint"
namespace std
{
using :: int8_t ;
using :: int16_t ;
using :: int32_t ;
using :: int64_t ;

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

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

using :: intmax_t ;
using :: intptr_t ;

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

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

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

using :: uintmax_t ;
using :: uintptr_t ;
}
#378 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/char_traits.h"
namespace std
{


template < >
struct char_traits < char16_t >
{
typedef char16_t char_type ;
typedef uint_least16_t int_type ;
typedef streamoff off_type ;
typedef u16streampos pos_type ;
typedef mbstate_t state_type ;

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

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

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

static int
compare ( const char_type * __s1 , const char_type * __s2 , size_t __n )
{
for ( size_t __i = 0 ; __i < __n ; ++ __i )
if ( lt ( __s1 [ __i ] , __s2 [ __i ] ) )
return - 1 ;
else if ( lt ( __s2 [ __i ] , __s1 [ __i ] ) )
return 1 ;
return 0 ;
}

static size_t
length ( const char_type * __s )
{
size_t __i = 0 ;
while ( ! eq ( __s [ __i ] , char_type ( ) ) )
++ __i ;
return __i ;
}

static const char_type *
find ( const char_type * __s , size_t __n , const char_type & __a )
{
for ( size_t __i = 0 ; __i < __n ; ++ __i )
if ( eq ( __s [ __i ] , __a ) )
return __s + __i ;
return 0 ;
}

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

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

static char_type *
assign ( char_type * __s , size_t __n , char_type __a )
{
for ( size_t __i = 0 ; __i < __n ; ++ __i )
assign ( __s [ __i ] , __a ) ;
return __s ;
}

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

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

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

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

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

template < >
struct char_traits < char32_t >
{
typedef char32_t char_type ;
typedef uint_least32_t int_type ;
typedef streamoff off_type ;
typedef u32streampos pos_type ;
typedef mbstate_t state_type ;

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

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

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

static int
compare ( const char_type * __s1 , const char_type * __s2 , size_t __n )
{
for ( size_t __i = 0 ; __i < __n ; ++ __i )
if ( lt ( __s1 [ __i ] , __s2 [ __i ] ) )
return - 1 ;
else if ( lt ( __s2 [ __i ] , __s1 [ __i ] ) )
return 1 ;
return 0 ;
}

static size_t
length ( const char_type * __s )
{
size_t __i = 0 ;
while ( ! eq ( __s [ __i ] , char_type ( ) ) )
++ __i ;
return __i ;
}

static const char_type *
find ( const char_type * __s , size_t __n , const char_type & __a )
{
for ( size_t __i = 0 ; __i < __n ; ++ __i )
if ( eq ( __s [ __i ] , __a ) )
return __s + __i ;
return 0 ;
}

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

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

static char_type *
assign ( char_type * __s , size_t __n , char_type __a )
{
for ( size_t __i = 0 ; __i < __n ; ++ __i )
assign ( __s [ __i ] , __a ) ;
return __s ;
}

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

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

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

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

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


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/allocator.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/c++allocator.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/new_allocator.h"
#40
namespace __gnu_cxx
{


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

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




typedef std :: true_type propagate_on_container_move_assignment ;


new_allocator ( ) noexcept { }

new_allocator ( const new_allocator & ) noexcept { }

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

~ new_allocator ( ) noexcept { }

pointer
address ( reference __x ) const noexcept
{ return std :: __addressof ( __x ) ; }

const_pointer
address ( const_reference __x ) const noexcept
{ return std :: __addressof ( __x ) ; }



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

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


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

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


template < typename _Up , typename ... _Args >
void
construct ( _Up * __p , _Args && ... __args )
{ :: new ( ( void * ) __p ) _Up ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename _Up >
void
destroy ( _Up * __p ) { __p -> ~ _Up ( ) ; }
#135
} ;

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

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


}
#36 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/c++allocator.h"
namespace std
{
#47
template < typename _Tp >
using __allocator_base = __gnu_cxx :: new_allocator < _Tp > ;
}
#52 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/allocator.h"
namespace std
{
#62
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 ; } ;




typedef true_type propagate_on_container_move_assignment ;

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

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




typedef true_type propagate_on_container_move_assignment ;


allocator ( ) throw ( ) { }

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

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

~ allocator ( ) throw ( ) { }


} ;

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

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

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

template < typename _Tp >
inline bool
operator != ( const allocator < _Tp > & , const allocator < _Tp > & )
{ return false ; }
#151
extern template class allocator < char > ;
extern template class allocator < wchar_t > ;
#159
template < typename _Alloc , bool = __oracle_is_empty ( _Alloc ) >
struct __alloc_swap
{ static void _S_do_it ( _Alloc & , _Alloc & ) { } } ;

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

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


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

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


template < typename _Tp , bool
= __or_ < is_copy_constructible < typename _Tp :: value_type > ,
is_nothrow_move_constructible < typename _Tp :: value_type >> :: value >
struct __shrink_to_fit_aux
{ static bool _S_do_it ( _Tp & ) { return false ; } } ;

template < typename _Tp >
struct __shrink_to_fit_aux < _Tp , true >
{
static bool
_S_do_it ( _Tp & __c )
{
try
{
_Tp ( __make_move_if_noexcept_iterator ( __c . begin ( ) ) ,
__make_move_if_noexcept_iterator ( __c . end ( ) ) ,
__c . get_allocator ( ) ) . swap ( __c ) ;
return true ;
}
catch ( ... )
{ return false ; }
}
} ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/localefwd.h"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/c++locale.h"
#39
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/clocale"
#39
#pragma GCC system_header
#1 "/usr/include/locale.h"
#9
#pragma ident "@(#)locale.h 1.20    03/12/04 SMI"
#1 "/usr/include/iso/locale_iso.h"
#45
#pragma ident "@(#)locale_iso.h 1.3 03/12/04 SMI"
#50
extern "C" {



namespace std {


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 ;
#91
} ;
#110
extern char * setlocale ( int , const char * ) ;
extern struct lconv * localeconv ( void ) ;
#118
}



}
#1 "/usr/include/libintl.h"
#11
#pragma ident "@(#)libintl.h    1.16    04/09/28 SMI"
#16
extern "C" {
#48
extern char * dcgettext ( const char * , const char * , const int ) ;
extern char * dgettext ( const char * , const char * ) ;
extern char * gettext ( const char * ) ;
extern char * textdomain ( const char * ) ;
extern char * bindtextdomain ( const char * , const char * ) ;





extern char * dcngettext ( const char * , const char * ,
const char * , unsigned long int , int ) ;
extern char * dngettext ( const char * , const char * ,
const char * , unsigned long int ) ;
extern char * ngettext ( const char * , const char * , unsigned long int ) ;
extern char * bind_textdomain_codeset ( const char * , const char * ) ;



extern int wdinit ( void ) ;
extern int wdchkind ( wchar_t ) ;
extern int wdbindf ( wchar_t , wchar_t , int ) ;
extern wchar_t * wddelim ( wchar_t , wchar_t , int ) ;
extern wchar_t mcfiller ( void ) ;
extern int mcwrap ( void ) ;
#102
}
#58 "/usr/include/locale.h"
using std :: lconv ;
using std :: setlocale ;
using std :: localeconv ;



extern "C" {
#74
}
#51 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/clocale"
namespace std
{
using :: lconv ;
using :: setlocale ;
using :: localeconv ;
}
#45 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/c++locale.h"
namespace std
{


typedef int * __c_locale ;





inline int
__convert_from_v ( const __c_locale & , char * __out ,
const int __size __attribute__ ( ( __unused__ ) ) ,
const char * __fmt , ... )
{
char * __old = std :: setlocale ( 1 , 0 ) ;
char * __sav = 0 ;
if ( __builtin_strcmp ( __old , "C" ) )
{
const size_t __len = __builtin_strlen ( __old ) + 1 ;
__sav = new char [ __len ] ;
__builtin_memcpy ( __sav , __old , __len ) ;
std :: setlocale ( 1 , "C" ) ;
}

__builtin_va_list __args ;
__builtin_va_start ( __args , __fmt ) ;


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




( ( void ) 0 ) ;

if ( __sav )
{
std :: setlocale ( 1 , __sav ) ;
delete [ ] __sav ;
}
return __ret ;
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/iosfwd"
#36
#pragma GCC system_header
#42
namespace std
{
#74
class ios_base ;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



typedef basic_ios < char > ios ;


typedef basic_streambuf < char > streambuf ;


typedef basic_istream < char > istream ;


typedef basic_ostream < char > ostream ;


typedef basic_iostream < char > iostream ;


typedef basic_stringbuf < char > stringbuf ;


typedef basic_istringstream < char > istringstream ;


typedef basic_ostringstream < char > ostringstream ;


typedef basic_stringstream < char > stringstream ;


typedef basic_filebuf < char > filebuf ;


typedef basic_ifstream < char > ifstream ;


typedef basic_ofstream < char > ofstream ;


typedef basic_fstream < char > fstream ;



typedef basic_ios < wchar_t > wios ;


typedef basic_streambuf < wchar_t > wstreambuf ;


typedef basic_istream < wchar_t > wistream ;


typedef basic_ostream < wchar_t > wostream ;


typedef basic_iostream < wchar_t > wiostream ;


typedef basic_stringbuf < wchar_t > wstringbuf ;


typedef basic_istringstream < wchar_t > wistringstream ;


typedef basic_ostringstream < wchar_t > wostringstream ;


typedef basic_stringstream < wchar_t > wstringstream ;


typedef basic_filebuf < wchar_t > wfilebuf ;


typedef basic_ifstream < wchar_t > wifstream ;


typedef basic_ofstream < wchar_t > wofstream ;


typedef basic_fstream < wchar_t > wfstream ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cctype"
#39
#pragma GCC system_header
#62
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 ;
}
#85
namespace std
{
using :: isblank ;
}
#44 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/localefwd.h"
namespace std
{
#55
class locale ;

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

template < > class ctype < wchar_t > ;

template < typename _CharT >
class ctype_byname ;


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

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

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



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

template < typename _CharT > class numpunct ;
template < typename _CharT > class numpunct_byname ;


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


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


class money_base ;

template < typename _CharT , typename _InIter = istreambuf_iterator < _CharT > >
class money_get ;
template < typename _CharT , typename _OutIter = ostreambuf_iterator < _CharT > >
class money_put ;

template < typename _CharT , bool _Intl = false >
class moneypunct ;
template < typename _CharT , bool _Intl = false >
class moneypunct_byname ;


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


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/ostream_insert.h"
#33
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/cxxabi_forced.h"
#34
#pragma GCC system_header

#pragma GCC visibility push ( default )


namespace __cxxabiv1
{
#48
class __forced_unwind
{
virtual ~ __forced_unwind ( ) throw ( ) ;


virtual void __pure_dummy ( ) = 0 ;
} ;
}


#pragma GCC visibility pop
#38 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/ostream_insert.h"
namespace std
{


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

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

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

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

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

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




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


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




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_function.h"
#59
namespace std
{
#100
template < typename _Arg , typename _Result >
struct unary_function
{

typedef _Arg argument_type ;


typedef _Result result_type ;
} ;




template < typename _Arg1 , typename _Arg2 , typename _Result >
struct binary_function
{

typedef _Arg1 first_argument_type ;


typedef _Arg2 second_argument_type ;


typedef _Result result_type ;
} ;
#139
template < typename _Tp >
struct plus : public binary_function < _Tp , _Tp , _Tp >
{
_Tp
operator ( ) ( const _Tp & __x , const _Tp & __y ) const
{ return __x + __y ; }
} ;


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


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


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


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


template < typename _Tp >
struct negate : public unary_function < _Tp , _Tp >
{
_Tp
operator ( ) ( const _Tp & __x ) const
{ return - __x ; }
} ;
#203
template < typename _Tp >
struct equal_to : public binary_function < _Tp , _Tp , bool >
{
bool
operator ( ) ( const _Tp & __x , const _Tp & __y ) const
{ return __x == __y ; }
} ;


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


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


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


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


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


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


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




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

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

template < typename _Tp >
struct bit_xor : public binary_function < _Tp , _Tp , _Tp >
{
_Tp
operator ( ) ( const _Tp & __x , const _Tp & __y ) const
{ return __x ^ __y ; }
} ;
#350
template < typename _Predicate >
class unary_negate
: public unary_function < typename _Predicate :: argument_type , bool >
{
protected :
_Predicate _M_pred ;

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

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


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


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

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

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


template < typename _Predicate >
inline binary_negate < _Predicate >
not2 ( const _Predicate & __pred )
{ return binary_negate < _Predicate > ( __pred ) ; }
#421
template < typename _Arg , typename _Result >
class pointer_to_unary_function : public unary_function < _Arg , _Result >
{
protected :
_Result ( * _M_ptr ) ( _Arg ) ;

public :
pointer_to_unary_function ( ) { }

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

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


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


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

public :
pointer_to_binary_function ( ) { }

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

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


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


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

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

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

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


template < typename _Pair2 >
typename _Pair2 :: first_type &
operator ( ) ( _Pair2 & __x ) const
{ return __x . first ; }

template < typename _Pair2 >
const typename _Pair2 :: first_type &
operator ( ) ( const _Pair2 & __x ) const
{ return __x . first ; }

} ;

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

const typename _Pair :: second_type &
operator ( ) ( const _Pair & __x ) const
{ return __x . second ; }
} ;
#541
template < typename _Ret , typename _Tp >
class mem_fun_t : public unary_function < _Tp * , _Ret >
{
public :
explicit
mem_fun_t ( _Ret ( _Tp :: * __pf ) ( ) )
: _M_f ( __pf ) { }

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

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



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

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

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



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

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

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



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

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

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



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

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

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



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

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

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



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

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

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



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

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

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



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

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

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

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

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

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

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

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




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/backward/binders.h"
#59
namespace std
{
#103
template < typename _Operation >
class binder1st
: public unary_function < typename _Operation :: second_argument_type ,
typename _Operation :: result_type >
{
protected :
_Operation op ;
typename _Operation :: first_argument_type value ;

public :
binder1st ( const _Operation & __x ,
const typename _Operation :: first_argument_type & __y )
: op ( __x ) , value ( __y ) { }

typename _Operation :: result_type
operator ( ) ( const typename _Operation :: second_argument_type & __x ) const
{ return op ( value , __x ) ; }



typename _Operation :: result_type
operator ( ) ( typename _Operation :: second_argument_type & __x ) const
{ return op ( value , __x ) ; }
} __attribute__ ( ( __deprecated__ ) ) ;


template < typename _Operation , typename _Tp >
inline binder1st < _Operation >
bind1st ( const _Operation & __fn , const _Tp & __x )
{
typedef typename _Operation :: first_argument_type _Arg1_type ;
return binder1st < _Operation > ( __fn , _Arg1_type ( __x ) ) ;
}


template < typename _Operation >
class binder2nd
: public unary_function < typename _Operation :: first_argument_type ,
typename _Operation :: result_type >
{
protected :
_Operation op ;
typename _Operation :: second_argument_type value ;

public :
binder2nd ( const _Operation & __x ,
const typename _Operation :: second_argument_type & __y )
: op ( __x ) , value ( __y ) { }

typename _Operation :: result_type
operator ( ) ( const typename _Operation :: first_argument_type & __x ) const
{ return op ( __x , value ) ; }



typename _Operation :: result_type
operator ( ) ( typename _Operation :: first_argument_type & __x ) const
{ return op ( __x , value ) ; }
} __attribute__ ( ( __deprecated__ ) ) ;


template < typename _Operation , typename _Tp >
inline binder2nd < _Operation >
bind2nd ( const _Operation & __fn , const _Tp & __x )
{
typedef typename _Operation :: second_argument_type _Arg2_type ;
return binder2nd < _Operation > ( __fn , _Arg2_type ( __x ) ) ;
}



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/range_access.h"
#33
#pragma GCC system_header



namespace std
{
#46
template < class _Container >
inline auto
begin ( _Container & __cont ) -> decltype ( __cont . begin ( ) )
{ return __cont . begin ( ) ; }
#56
template < class _Container >
inline auto
begin ( const _Container & __cont ) -> decltype ( __cont . begin ( ) )
{ return __cont . begin ( ) ; }
#66
template < class _Container >
inline auto
end ( _Container & __cont ) -> decltype ( __cont . end ( ) )
{ return __cont . end ( ) ; }
#76
template < class _Container >
inline auto
end ( const _Container & __cont ) -> decltype ( __cont . end ( ) )
{ return __cont . end ( ) ; }





template < class _Tp , size_t _Nm >
inline _Tp *
begin ( _Tp ( & __arr ) [ _Nm ] )
{ return __arr ; }
#95
template < class _Tp , size_t _Nm >
inline _Tp *
end ( _Tp ( & __arr ) [ _Nm ] )
{ return __arr + _Nm ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_string.h"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/atomicity.h"
#32
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/gthr.h"
#30
#pragma GCC visibility push ( default )
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/gthr-default.h"
#1 "/usr/include/pthread.h"
#9
#pragma ident "@(#)pthread.h    1.37    04/09/28 SMI"
#1 "/usr/include/sched.h"
#9
#pragma ident "@(#)sched.h  1.10    03/03/06 SMI"
#15
extern "C" {


struct sched_param {
int sched_priority ;
int sched_nicelim ;
int sched_nice ;
int sched_pad [ 6 ] ;



} ;
#42
int sched_getparam ( pid_t , struct sched_param * ) ;
int sched_setparam ( pid_t , const struct sched_param * ) ;
int sched_getscheduler ( pid_t ) ;
int sched_setscheduler ( pid_t , int , const struct sched_param * ) ;
int sched_yield ( void ) ;
int sched_get_priority_max ( int ) ;
int sched_get_priority_min ( int ) ;
int sched_rr_get_interval ( pid_t , struct timespec * ) ;
#62
}
#20 "/usr/include/pthread.h"
extern "C" {
#120
typedef struct _cleanup {
uintptr_t pthread_cleanup_pad [ 4 ] ;
} _cleanup_t ;



void __pthread_cleanup_push ( void ( * ) ( void * ) , void * , caddr_t , _cleanup_t * ) ;
void __pthread_cleanup_pop ( int , _cleanup_t * ) ;
caddr_t _getfp ( void ) ;
#139
extern "C" {


typedef void ( * _Voidfp ) ( void * ) ;


}
#170
extern int pthread_atfork ( void ( * ) ( void ) , void ( * ) ( void ) , void ( * ) ( void ) ) ;
extern int pthread_attr_init ( pthread_attr_t * ) ;
extern int pthread_attr_destroy ( pthread_attr_t * ) ;
extern int pthread_attr_setstack ( pthread_attr_t * , void * , size_t ) ;
extern int pthread_attr_getstack ( const pthread_attr_t * ,
void * * , size_t * ) ;
extern int pthread_attr_setstacksize ( pthread_attr_t * , size_t ) ;
extern int pthread_attr_getstacksize ( const pthread_attr_t * ,
size_t * ) ;
extern int pthread_attr_setstackaddr ( pthread_attr_t * , void * ) ;
extern int pthread_attr_getstackaddr ( const pthread_attr_t * ,
void * * ) ;
extern int pthread_attr_setdetachstate ( pthread_attr_t * , int ) ;
extern int pthread_attr_getdetachstate ( const pthread_attr_t * , int * ) ;
extern int pthread_attr_setscope ( pthread_attr_t * , int ) ;
extern int pthread_attr_getscope ( const pthread_attr_t * ,
int * ) ;
extern int pthread_attr_setinheritsched ( pthread_attr_t * , int ) ;
extern int pthread_attr_getinheritsched ( const pthread_attr_t * ,
int * ) ;
extern int pthread_attr_setschedpolicy ( pthread_attr_t * , int ) ;
extern int pthread_attr_getschedpolicy ( const pthread_attr_t * ,
int * ) ;
extern int pthread_attr_setschedparam ( pthread_attr_t * ,
const struct sched_param * ) ;
extern int pthread_attr_getschedparam ( const pthread_attr_t * ,
struct sched_param * ) ;
extern int pthread_create ( pthread_t * ,
const pthread_attr_t * , void * ( * ) ( void * ) ,
void * ) ;
extern int pthread_once ( pthread_once_t * , void ( * ) ( void ) ) ;
extern int pthread_join ( pthread_t , void * * ) ;
extern int pthread_detach ( pthread_t ) ;
extern void pthread_exit ( void * ) ;
extern int pthread_cancel ( pthread_t ) ;
extern int pthread_setschedparam ( pthread_t , int , const struct sched_param * ) ;
extern int pthread_getschedparam ( pthread_t , int * ,
struct sched_param * ) ;
extern int pthread_setschedprio ( pthread_t , int ) ;
extern int pthread_setcancelstate ( int , int * ) ;
extern int pthread_setcanceltype ( int , int * ) ;
extern void pthread_testcancel ( void ) ;
extern int pthread_equal ( pthread_t , pthread_t ) ;
extern int pthread_key_create ( pthread_key_t * , void ( * ) ( void * ) ) ;
extern int pthread_key_delete ( pthread_key_t ) ;
extern int pthread_setspecific ( pthread_key_t , const void * ) ;
extern void * pthread_getspecific ( pthread_key_t ) ;
extern pthread_t pthread_self ( void ) ;




extern int pthread_mutexattr_init ( pthread_mutexattr_t * ) ;
extern int pthread_mutexattr_destroy ( pthread_mutexattr_t * ) ;
extern int pthread_mutexattr_setpshared ( pthread_mutexattr_t * , int ) ;
extern int pthread_mutexattr_getpshared (
const pthread_mutexattr_t * , int * ) ;
extern int pthread_mutexattr_setprotocol ( pthread_mutexattr_t * , int ) ;
extern int pthread_mutexattr_getprotocol (
const pthread_mutexattr_t * , int * ) ;
extern int pthread_mutexattr_setprioceiling ( pthread_mutexattr_t * , int ) ;
extern int pthread_mutexattr_getprioceiling (
const pthread_mutexattr_t * , int * ) ;
extern int pthread_mutexattr_setrobust_np ( pthread_mutexattr_t * , int ) ;
extern int pthread_mutexattr_getrobust_np (
const pthread_mutexattr_t * , int * ) ;
extern int pthread_mutex_init ( pthread_mutex_t * ,
const pthread_mutexattr_t * ) ;
extern int pthread_mutex_consistent_np ( pthread_mutex_t * ) ;
extern int pthread_mutex_destroy ( pthread_mutex_t * ) ;
extern int pthread_mutex_lock ( pthread_mutex_t * ) ;
extern int pthread_mutex_timedlock ( pthread_mutex_t * ,
const struct timespec * ) ;
extern int pthread_mutex_reltimedlock_np ( pthread_mutex_t * ,
const struct timespec * ) ;
extern int pthread_mutex_unlock ( pthread_mutex_t * ) ;
extern int pthread_mutex_trylock ( pthread_mutex_t * ) ;
extern int pthread_mutex_setprioceiling ( pthread_mutex_t * ,
int , int * ) ;
extern int pthread_mutex_getprioceiling ( const pthread_mutex_t * ,
int * ) ;
extern int pthread_condattr_init ( pthread_condattr_t * ) ;
extern int pthread_condattr_destroy ( pthread_condattr_t * ) ;
extern int pthread_condattr_setclock ( pthread_condattr_t * , clockid_t ) ;
extern int pthread_condattr_getclock ( const pthread_condattr_t * ,
clockid_t * ) ;
extern int pthread_condattr_setpshared ( pthread_condattr_t * , int ) ;
extern int pthread_condattr_getpshared ( const pthread_condattr_t * ,
int * ) ;
extern int pthread_cond_init ( pthread_cond_t * ,
const pthread_condattr_t * ) ;
extern int pthread_cond_destroy ( pthread_cond_t * ) ;
extern int pthread_cond_broadcast ( pthread_cond_t * ) ;
extern int pthread_cond_signal ( pthread_cond_t * ) ;
extern int pthread_cond_wait ( pthread_cond_t * ,
pthread_mutex_t * ) ;
extern int pthread_cond_timedwait ( pthread_cond_t * ,
pthread_mutex_t * , const struct timespec * ) ;
extern int pthread_cond_reltimedwait_np ( pthread_cond_t * ,
pthread_mutex_t * , const struct timespec * ) ;
extern int pthread_attr_getguardsize ( const pthread_attr_t * ,
size_t * ) ;
extern int pthread_attr_setguardsize ( pthread_attr_t * , size_t ) ;
extern int pthread_getconcurrency ( void ) ;
extern int pthread_setconcurrency ( int ) ;
extern int pthread_mutexattr_settype ( pthread_mutexattr_t * , int ) ;
extern int pthread_mutexattr_gettype ( const pthread_mutexattr_t * ,
int * ) ;
extern int pthread_rwlock_init ( pthread_rwlock_t * ,
const pthread_rwlockattr_t * ) ;
extern int pthread_rwlock_destroy ( pthread_rwlock_t * ) ;
extern int pthread_rwlock_rdlock ( pthread_rwlock_t * ) ;
extern int pthread_rwlock_timedrdlock ( pthread_rwlock_t * ,
const struct timespec * ) ;
extern int pthread_rwlock_reltimedrdlock_np ( pthread_rwlock_t * ,
const struct timespec * ) ;
extern int pthread_rwlock_tryrdlock ( pthread_rwlock_t * ) ;
extern int pthread_rwlock_wrlock ( pthread_rwlock_t * ) ;
extern int pthread_rwlock_timedwrlock ( pthread_rwlock_t * ,
const struct timespec * ) ;
extern int pthread_rwlock_reltimedwrlock_np ( pthread_rwlock_t * ,
const struct timespec * ) ;
extern int pthread_rwlock_trywrlock ( pthread_rwlock_t * ) ;
extern int pthread_rwlock_unlock ( pthread_rwlock_t * ) ;
extern int pthread_rwlockattr_init ( pthread_rwlockattr_t * ) ;
extern int pthread_rwlockattr_destroy ( pthread_rwlockattr_t * ) ;
extern int pthread_rwlockattr_getpshared (
const pthread_rwlockattr_t * , int * ) ;
extern int pthread_rwlockattr_setpshared ( pthread_rwlockattr_t * , int ) ;
extern int pthread_spin_init ( pthread_spinlock_t * , int ) ;
extern int pthread_spin_destroy ( pthread_spinlock_t * ) ;
extern int pthread_spin_lock ( pthread_spinlock_t * ) ;
extern int pthread_spin_trylock ( pthread_spinlock_t * ) ;
extern int pthread_spin_unlock ( pthread_spinlock_t * ) ;
extern int pthread_barrierattr_init ( pthread_barrierattr_t * ) ;
extern int pthread_barrierattr_destroy ( pthread_barrierattr_t * ) ;
extern int pthread_barrierattr_setpshared ( pthread_barrierattr_t * , int ) ;
extern int pthread_barrierattr_getpshared (
const pthread_barrierattr_t * , int * ) ;
extern int pthread_barrier_init ( pthread_barrier_t * ,
const pthread_barrierattr_t * , uint_t ) ;
extern int pthread_barrier_destroy ( pthread_barrier_t * ) ;
extern int pthread_barrier_wait ( pthread_barrier_t * ) ;
#427
}
#47 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/gthr-default.h"
typedef pthread_t __gthread_t ;
typedef pthread_key_t __gthread_key_t ;
typedef pthread_once_t __gthread_once_t ;
typedef pthread_mutex_t __gthread_mutex_t ;
typedef pthread_mutex_t __gthread_recursive_mutex_t ;
typedef pthread_cond_t __gthread_cond_t ;
typedef struct timespec __gthread_time_t ;
#101
static __typeof ( pthread_once ) __gthrw_pthread_once __attribute__ ( ( __weakref__ ( "pthread_once" ) ) ) ;
static __typeof ( pthread_getspecific ) __gthrw_pthread_getspecific __attribute__ ( ( __weakref__ ( "pthread_getspecific"
#102
) ) ) ;
static __typeof ( pthread_setspecific ) __gthrw_pthread_setspecific __attribute__ ( ( __weakref__ ( "pthread_setspecific"
#103
) ) ) ;

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

static __typeof ( pthread_cancel ) __gthrw_pthread_cancel __attribute__ ( ( __weakref__ ( "pthread_cancel" ) ) ) ;

static __typeof ( sched_yield ) __gthrw_sched_yield __attribute__ ( ( __weakref__ ( "sched_yield" ) ) ) ;

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

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

static __typeof ( pthread_mutex_unlock ) __gthrw_pthread_mutex_unlock __attribute__ ( ( __weakref__ ( "pthread_mutex_unlock"
#120
) ) ) ;
static __typeof ( pthread_mutex_init ) __gthrw_pthread_mutex_init __attribute__ ( ( __weakref__ ( "pthread_mutex_init" )
#121
) ) ;
static __typeof ( pthread_mutex_destroy ) __gthrw_pthread_mutex_destroy __attribute__ ( ( __weakref__ ( "pthread_mutex_destroy"
#122
) ) ) ;

static __typeof ( pthread_cond_init ) __gthrw_pthread_cond_init __attribute__ ( ( __weakref__ ( "pthread_cond_init" ) ) )
#124
;
static __typeof ( pthread_cond_broadcast ) __gthrw_pthread_cond_broadcast __attribute__ ( ( __weakref__ ( "pthread_cond_broadcast"
#125
) ) ) ;
static __typeof ( pthread_cond_signal ) __gthrw_pthread_cond_signal __attribute__ ( ( __weakref__ ( "pthread_cond_signal"
#126
) ) ) ;
static __typeof ( pthread_cond_wait ) __gthrw_pthread_cond_wait __attribute__ ( ( __weakref__ ( "pthread_cond_wait" ) ) )
#127
;
static __typeof ( pthread_cond_timedwait ) __gthrw_pthread_cond_timedwait __attribute__ ( ( __weakref__ ( "pthread_cond_timedwait"
#128
) ) ) ;
static __typeof ( pthread_cond_destroy ) __gthrw_pthread_cond_destroy __attribute__ ( ( __weakref__ ( "pthread_cond_destroy"
#129
) ) ) ;

static __typeof ( pthread_key_create ) __gthrw_pthread_key_create __attribute__ ( ( __weakref__ ( "pthread_key_create" )
#131
) ) ;
static __typeof ( pthread_key_delete ) __gthrw_pthread_key_delete __attribute__ ( ( __weakref__ ( "pthread_key_delete" )
#132
) ) ;
static __typeof ( pthread_mutexattr_init ) __gthrw_pthread_mutexattr_init __attribute__ ( ( __weakref__ ( "pthread_mutexattr_init"
#133
) ) ) ;
static __typeof ( pthread_mutexattr_settype ) __gthrw_pthread_mutexattr_settype __attribute__ ( ( __weakref__ ( "pthread_mutexattr_settype"
#134
) ) ) ;
static __typeof ( pthread_mutexattr_destroy ) __gthrw_pthread_mutexattr_destroy __attribute__ ( ( __weakref__ ( "pthread_mutexattr_destroy"
#135
) ) ) ;
#246
static inline int
__gthread_active_p ( void )
{
static void * const __gthread_active_ptr
= ( void * ) & __gthrw_pthread_cancel ;
return __gthread_active_ptr != 0 ;
}
#658
static inline int
__gthread_create ( __gthread_t * __threadid , void * ( * __func ) ( void * ) ,
void * __args )
{
return __gthrw_pthread_create ( __threadid , 0L , __func , __args ) ;
}

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

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

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

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

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

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

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

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

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

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

static inline void
__gthread_mutex_init_function ( __gthread_mutex_t * __mutex )
{
if ( __gthread_active_p ( ) )
__gthrw_pthread_mutex_init ( __mutex , 0L ) ;
}

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

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

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


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


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



static inline int
__gthread_recursive_mutex_init_function ( __gthread_recursive_mutex_t * __mutex )
{
if ( __gthread_active_p ( ) )
{
pthread_mutexattr_t __attr ;
int __r ;

__r = __gthrw_pthread_mutexattr_init ( & __attr ) ;
if ( ! __r )
__r = __gthrw_pthread_mutexattr_settype ( & __attr ,
0x4 ) ;
if ( ! __r )
__r = __gthrw_pthread_mutex_init ( __mutex , & __attr ) ;
if ( ! __r )
__r = __gthrw_pthread_mutexattr_destroy ( & __attr ) ;
return __r ;
}
return 0 ;
}


static inline int
__gthread_recursive_mutex_lock ( __gthread_recursive_mutex_t * __mutex )
{
return __gthread_mutex_lock ( __mutex ) ;
}

static inline int
__gthread_recursive_mutex_trylock ( __gthread_recursive_mutex_t * __mutex )
{
return __gthread_mutex_trylock ( __mutex ) ;
}


static inline int
__gthread_recursive_mutex_timedlock ( __gthread_recursive_mutex_t * __mutex ,
const __gthread_time_t * __abs_timeout )
{
return __gthread_mutex_timedlock ( __mutex , __abs_timeout ) ;
}


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

static inline int
__gthread_recursive_mutex_destroy ( __gthread_recursive_mutex_t * __mutex )
{
return __gthread_mutex_destroy ( __mutex ) ;
}


static inline void
__gthread_cond_init_function ( __gthread_cond_t * __cond )
{
if ( __gthread_active_p ( ) )
__gthrw_pthread_cond_init ( __cond , 0L ) ;
}


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

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

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

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

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

static inline int
__gthread_cond_destroy ( __gthread_cond_t * __cond )
{
return __gthrw_pthread_cond_destroy ( __cond ) ;
}
#151 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/gthr.h"
#pragma GCC visibility pop
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/atomic_word.h"
#32
typedef int _Atomic_word ;
#38 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/atomicity.h"
namespace __gnu_cxx
{
#55
_Atomic_word
__attribute__ ( ( __unused__ ) )
__exchange_and_add ( volatile _Atomic_word * , int ) throw ( ) ;

void
__attribute__ ( ( __unused__ ) )
__atomic_add ( volatile _Atomic_word * , int ) throw ( ) ;


static inline _Atomic_word
__exchange_and_add_single ( _Atomic_word * __mem , int __val )
{
_Atomic_word __result = * __mem ;
* __mem += __val ;
return __result ;
}

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

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

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



}

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

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



}


}
#45 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_string.h"
namespace std
{
#111
template < typename _CharT , typename _Traits , typename _Alloc >
class basic_string
{
typedef typename _Alloc :: template rebind < _CharT > :: other _CharT_alloc_type ;


public :
typedef _Traits traits_type ;
typedef typename _Traits :: char_type value_type ;
typedef _Alloc allocator_type ;
typedef typename _CharT_alloc_type :: size_type size_type ;
typedef typename _CharT_alloc_type :: difference_type difference_type ;
typedef typename _CharT_alloc_type :: reference reference ;
typedef typename _CharT_alloc_type :: const_reference const_reference ;
typedef typename _CharT_alloc_type :: pointer pointer ;
typedef typename _CharT_alloc_type :: const_pointer const_pointer ;
typedef __gnu_cxx :: __normal_iterator < pointer , basic_string > iterator ;
typedef __gnu_cxx :: __normal_iterator < const_pointer , basic_string >
const_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;
typedef std :: reverse_iterator < iterator > reverse_iterator ;

private :
#148
struct _Rep_base
{
size_type _M_length ;
size_type _M_capacity ;
_Atomic_word _M_refcount ;
} ;

struct _Rep : _Rep_base
{

typedef typename _Alloc :: template rebind < char > :: other _Raw_bytes_alloc ;
#173
static const size_type _S_max_size ;
static const _CharT _S_terminal ;



static size_type _S_empty_rep_storage [ ] ;

static _Rep &
_S_empty_rep ( )
{



void * __p = reinterpret_cast < void * > ( & _S_empty_rep_storage ) ;
return * reinterpret_cast < _Rep * > ( __p ) ;
}

bool
_M_is_leaked ( ) const
{ return this -> _M_refcount < 0 ; }

bool
_M_is_shared ( ) const
{ return this -> _M_refcount > 0 ; }

void
_M_set_leaked ( )
{ this -> _M_refcount = - 1 ; }

void
_M_set_sharable ( )
{ this -> _M_refcount = 0 ; }

void
_M_set_length_and_sharable ( size_type __n )
{

if ( this != & _S_empty_rep ( ) )

{
this -> _M_set_sharable ( ) ;
this -> _M_length = __n ;
traits_type :: assign ( this -> _M_refdata ( ) [ __n ] , _S_terminal ) ;


}
}

_CharT *
_M_refdata ( ) throw ( )
{ return reinterpret_cast < _CharT * > ( this + 1 ) ; }

_CharT *
_M_grab ( const _Alloc & __alloc1 , const _Alloc & __alloc2 )
{
return ( ! _M_is_leaked ( ) && __alloc1 == __alloc2 )
? _M_refcopy ( ) : _M_clone ( __alloc1 ) ;
}


static _Rep *
_S_create ( size_type , size_type , const _Alloc & ) ;

void
_M_dispose ( const _Alloc & __a )
{

if ( this != & _S_empty_rep ( ) )

{

;
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & this -> _M_refcount ,
- 1 ) <= 0 )
{
;
_M_destroy ( __a ) ;
}
}
}

void
_M_destroy ( const _Alloc & ) throw ( ) ;

_CharT *
_M_refcopy ( ) throw ( )
{

if ( this != & _S_empty_rep ( ) )

__gnu_cxx :: __atomic_add_dispatch ( & this -> _M_refcount , 1 ) ;
return _M_refdata ( ) ;
}

_CharT *
_M_clone ( const _Alloc & , size_type __res = 0 ) ;
} ;


struct _Alloc_hider : _Alloc
{
_Alloc_hider ( _CharT * __dat , const _Alloc & __a )
: _Alloc ( __a ) , _M_p ( __dat ) { }

_CharT * _M_p ;
} ;

public :




static const size_type npos = static_cast < size_type > ( - 1 ) ;

private :

mutable _Alloc_hider _M_dataplus ;

_CharT *
_M_data ( ) const
{ return _M_dataplus . _M_p ; }

_CharT *
_M_data ( _CharT * __p )
{ return ( _M_dataplus . _M_p = __p ) ; }

_Rep *
_M_rep ( ) const
{ return & ( ( reinterpret_cast < _Rep * > ( _M_data ( ) ) ) [ - 1 ] ) ; }



iterator
_M_ibegin ( ) const
{ return iterator ( _M_data ( ) ) ; }

iterator
_M_iend ( ) const
{ return iterator ( _M_data ( ) + this -> size ( ) ) ; }

void
_M_leak ( )
{
if ( ! _M_rep ( ) -> _M_is_leaked ( ) )
_M_leak_hard ( ) ;
}

size_type
_M_check ( size_type __pos , const char * __s ) const
{
if ( __pos > this -> size ( ) )
__throw_out_of_range ( ( __s ) ) ;
return __pos ;
}

void
_M_check_length ( size_type __n1 , size_type __n2 , const char * __s ) const
{
if ( this -> max_size ( ) - ( this -> size ( ) - __n1 ) < __n2 )
__throw_length_error ( ( __s ) ) ;
}


size_type
_M_limit ( size_type __pos , size_type __off ) const
{
const bool __testoff = __off < this -> size ( ) - __pos ;
return __testoff ? __off : this -> size ( ) - __pos ;
}


bool
_M_disjunct ( const _CharT * __s ) const
{
return ( less < const _CharT * > ( ) ( __s , _M_data ( ) )
|| less < const _CharT * > ( ) ( _M_data ( ) + this -> size ( ) , __s ) ) ;
}



static void
_M_copy ( _CharT * __d , const _CharT * __s , size_type __n )
{
if ( __n == 1 )
traits_type :: assign ( * __d , * __s ) ;
else
traits_type :: copy ( __d , __s , __n ) ;
}

static void
_M_move ( _CharT * __d , const _CharT * __s , size_type __n )
{
if ( __n == 1 )
traits_type :: assign ( * __d , * __s ) ;
else
traits_type :: move ( __d , __s , __n ) ;
}

static void
_M_assign ( _CharT * __d , size_type __n , _CharT __c )
{
if ( __n == 1 )
traits_type :: assign ( * __d , __c ) ;
else
traits_type :: assign ( __d , __n , __c ) ;
}



template < class _Iterator >
static void
_S_copy_chars ( _CharT * __p , _Iterator __k1 , _Iterator __k2 )
{
for ( ; __k1 != __k2 ; ++ __k1 , ++ __p )
traits_type :: assign ( * __p , * __k1 ) ;
}

static void
_S_copy_chars ( _CharT * __p , iterator __k1 , iterator __k2 )
{ _S_copy_chars ( __p , __k1 . base ( ) , __k2 . base ( ) ) ; }

static void
_S_copy_chars ( _CharT * __p , const_iterator __k1 , const_iterator __k2 )
{ _S_copy_chars ( __p , __k1 . base ( ) , __k2 . base ( ) ) ; }

static void
_S_copy_chars ( _CharT * __p , _CharT * __k1 , _CharT * __k2 )
{ _M_copy ( __p , __k1 , __k2 - __k1 ) ; }

static void
_S_copy_chars ( _CharT * __p , const _CharT * __k1 , const _CharT * __k2 )
{ _M_copy ( __p , __k1 , __k2 - __k1 ) ; }

static int
_S_compare ( size_type __n1 , size_type __n2 )
{
const difference_type __d = difference_type ( __n1 - __n2 ) ;

if ( __d > __gnu_cxx :: __numeric_traits < int > :: __max )
return __gnu_cxx :: __numeric_traits < int > :: __max ;
else if ( __d < __gnu_cxx :: __numeric_traits < int > :: __min )
return __gnu_cxx :: __numeric_traits < int > :: __min ;
else
return int ( __d ) ;
}

void
_M_mutate ( size_type __pos , size_type __len1 , size_type __len2 ) ;

void
_M_leak_hard ( ) ;

static _Rep &
_S_empty_rep ( )
{ return _Rep :: _S_empty_rep ( ) ; }

public :
#437
basic_string ( )

: _M_dataplus ( _S_empty_rep ( ) . _M_refdata ( ) , _Alloc ( ) ) { }
#447
explicit
basic_string ( const _Alloc & __a ) ;
#455
basic_string ( const basic_string & __str ) ;
#462
basic_string ( const basic_string & __str , size_type __pos ,
size_type __n = npos ) ;
#471
basic_string ( const basic_string & __str , size_type __pos ,
size_type __n , const _Alloc & __a ) ;
#483
basic_string ( const _CharT * __s , size_type __n ,
const _Alloc & __a = _Alloc ( ) ) ;





basic_string ( const _CharT * __s , const _Alloc & __a = _Alloc ( ) ) ;
#497
basic_string ( size_type __n , _CharT __c , const _Alloc & __a = _Alloc ( ) ) ;
#507
basic_string ( basic_string && __str ) noexcept
: _M_dataplus ( __str . _M_dataplus )
{

__str . _M_data ( _S_empty_rep ( ) . _M_refdata ( ) ) ;



}
#522
basic_string ( initializer_list < _CharT > __l , const _Alloc & __a = _Alloc ( ) ) ;
#531
template < class _InputIterator >
basic_string ( _InputIterator __beg , _InputIterator __end ,
const _Alloc & __a = _Alloc ( ) ) ;




~ basic_string ( ) noexcept
{ _M_rep ( ) -> _M_dispose ( this -> get_allocator ( ) ) ; }





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





basic_string &
operator = ( const _CharT * __s )
{ return this -> assign ( __s ) ; }
#564
basic_string &
operator = ( _CharT __c )
{
this -> assign ( 1 , __c ) ;
return * this ;
}
#579
basic_string &
operator = ( basic_string && __str )
{

this -> swap ( __str ) ;
return * this ;
}





basic_string &
operator = ( initializer_list < _CharT > __l )
{
this -> assign ( __l . begin ( ) , __l . size ( ) ) ;
return * this ;
}
#604
iterator
begin ( ) noexcept
{
_M_leak ( ) ;
return iterator ( _M_data ( ) ) ;
}





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





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





const_iterator
end ( ) const noexcept
{ return const_iterator ( _M_data ( ) + this -> size ( ) ) ; }
#643
reverse_iterator
rbegin ( ) noexcept
{ return reverse_iterator ( this -> end ( ) ) ; }
#652
const_reverse_iterator
rbegin ( ) const noexcept
{ return const_reverse_iterator ( this -> end ( ) ) ; }
#661
reverse_iterator
rend ( ) noexcept
{ return reverse_iterator ( this -> begin ( ) ) ; }
#670
const_reverse_iterator
rend ( ) const noexcept
{ return const_reverse_iterator ( this -> begin ( ) ) ; }
#679
const_iterator
cbegin ( ) const noexcept
{ return const_iterator ( this -> _M_data ( ) ) ; }





const_iterator
cend ( ) const noexcept
{ return const_iterator ( this -> _M_data ( ) + this -> size ( ) ) ; }
#696
const_reverse_iterator
crbegin ( ) const noexcept
{ return const_reverse_iterator ( this -> end ( ) ) ; }
#705
const_reverse_iterator
crend ( ) const noexcept
{ return const_reverse_iterator ( this -> begin ( ) ) ; }


public :



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



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


size_type
max_size ( ) const noexcept
{ return _Rep :: _S_max_size ; }
#739
void
resize ( size_type __n , _CharT __c ) ;
#752
void
resize ( size_type __n )
{ this -> resize ( __n , _CharT ( ) ) ; }



void
shrink_to_fit ( )
{
if ( capacity ( ) > size ( ) )
{
try
{ reserve ( 0 ) ; }
catch ( ... )
{ }
}
}
#775
size_type
capacity ( ) const noexcept
{ return _M_rep ( ) -> _M_capacity ; }
#796
void
reserve ( size_type __res_arg = 0 ) ;




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





bool
empty ( ) const noexcept
{ return this -> size ( ) == 0 ; }
#825
const_reference
operator [ ] ( size_type __pos ) const
{
;
return _M_data ( ) [ __pos ] ;
}
#842
reference
operator [ ] ( size_type __pos )
{

;

;
_M_leak ( ) ;
return _M_data ( ) [ __pos ] ;
}
#863
const_reference
at ( size_type __n ) const
{
if ( __n >= this -> size ( ) )
__throw_out_of_range ( ( "basic_string::at" ) ) ;
return _M_data ( ) [ __n ] ;
}
#882
reference
at ( size_type __n )
{
if ( __n >= size ( ) )
__throw_out_of_range ( ( "basic_string::at" ) ) ;
_M_leak ( ) ;
return _M_data ( ) [ __n ] ;
}
#896
reference
front ( )
{ return operator [ ] ( 0 ) ; }





const_reference
front ( ) const
{ return operator [ ] ( 0 ) ; }





reference
back ( )
{ return operator [ ] ( this -> size ( ) - 1 ) ; }





const_reference
back ( ) const
{ return operator [ ] ( this -> size ( ) - 1 ) ; }
#931
basic_string &
operator += ( const basic_string & __str )
{ return this -> append ( __str ) ; }
#940
basic_string &
operator += ( const _CharT * __s )
{ return this -> append ( __s ) ; }
#949
basic_string &
operator += ( _CharT __c )
{
this -> push_back ( __c ) ;
return * this ;
}
#962
basic_string &
operator += ( initializer_list < _CharT > __l )
{ return this -> append ( __l . begin ( ) , __l . size ( ) ) ; }
#972
basic_string &
append ( const basic_string & __str ) ;
#988
basic_string &
append ( const basic_string & __str , size_type __pos , size_type __n ) ;
#997
basic_string &
append ( const _CharT * __s , size_type __n ) ;
#1005
basic_string &
append ( const _CharT * __s )
{
;
return this -> append ( __s , traits_type :: length ( __s ) ) ;
}
#1020
basic_string &
append ( size_type __n , _CharT __c ) ;
#1029
basic_string &
append ( initializer_list < _CharT > __l )
{ return this -> append ( __l . begin ( ) , __l . size ( ) ) ; }
#1042
template < class _InputIterator >
basic_string &
append ( _InputIterator __first , _InputIterator __last )
{ return this -> replace ( _M_iend ( ) , _M_iend ( ) , __first , __last ) ; }





void
push_back ( _CharT __c )
{
const size_type __len = 1 + this -> size ( ) ;
if ( __len > this -> capacity ( ) || _M_rep ( ) -> _M_is_shared ( ) )
this -> reserve ( __len ) ;
traits_type :: assign ( _M_data ( ) [ this -> size ( ) ] , __c ) ;
_M_rep ( ) -> _M_set_length_and_sharable ( __len ) ;
}
#1066
basic_string &
assign ( const basic_string & __str ) ;
#1078
basic_string &
assign ( basic_string && __str )
{
this -> swap ( __str ) ;
return * this ;
}
#1099
basic_string &
assign ( const basic_string & __str , size_type __pos , size_type __n )
{ return this -> assign ( __str . _M_data ( )
+ __str . _M_check ( __pos , "basic_string::assign" ) ,
__str . _M_limit ( __pos , __n ) ) ; }
#1115
basic_string &
assign ( const _CharT * __s , size_type __n ) ;
#1127
basic_string &
assign ( const _CharT * __s )
{
;
return this -> assign ( __s , traits_type :: length ( __s ) ) ;
}
#1143
basic_string &
assign ( size_type __n , _CharT __c )
{ return _M_replace_aux ( size_type ( 0 ) , this -> size ( ) , __n , __c ) ; }
#1155
template < class _InputIterator >
basic_string &
assign ( _InputIterator __first , _InputIterator __last )
{ return this -> replace ( _M_ibegin ( ) , _M_iend ( ) , __first , __last ) ; }
#1166
basic_string &
assign ( initializer_list < _CharT > __l )
{ return this -> assign ( __l . begin ( ) , __l . size ( ) ) ; }
#1184
void
insert ( iterator __p , size_type __n , _CharT __c )
{ this -> replace ( __p , __p , __n , __c ) ; }
#1200
template < class _InputIterator >
void
insert ( iterator __p , _InputIterator __beg , _InputIterator __end )
{ this -> replace ( __p , __p , __beg , __end ) ; }
#1212
void
insert ( iterator __p , initializer_list < _CharT > __l )
{
;
this -> insert ( __p - _M_ibegin ( ) , __l . begin ( ) , __l . size ( ) ) ;
}
#1232
basic_string &
insert ( size_type __pos1 , const basic_string & __str )
{ return this -> insert ( __pos1 , __str , size_type ( 0 ) , __str . size ( ) ) ; }
#1254
basic_string &
insert ( size_type __pos1 , const basic_string & __str ,
size_type __pos2 , size_type __n )
{ return this -> insert ( __pos1 , __str . _M_data ( )
+ __str . _M_check ( __pos2 , "basic_string::insert" ) ,
__str . _M_limit ( __pos2 , __n ) ) ; }
#1277
basic_string &
insert ( size_type __pos , const _CharT * __s , size_type __n ) ;
#1295
basic_string &
insert ( size_type __pos , const _CharT * __s )
{
;
return this -> insert ( __pos , __s , traits_type :: length ( __s ) ) ;
}
#1318
basic_string &
insert ( size_type __pos , size_type __n , _CharT __c )
{ return _M_replace_aux ( _M_check ( __pos , "basic_string::insert" ) ,
size_type ( 0 ) , __n , __c ) ; }
#1336
iterator
insert ( iterator __p , _CharT __c )
{
;
const size_type __pos = __p - _M_ibegin ( ) ;
_M_replace_aux ( __pos , size_type ( 0 ) , size_type ( 1 ) , __c ) ;
_M_rep ( ) -> _M_set_leaked ( ) ;
return iterator ( _M_data ( ) + __pos ) ;
}
#1361
basic_string &
erase ( size_type __pos = 0 , size_type __n = npos )
{
_M_mutate ( _M_check ( __pos , "basic_string::erase" ) ,
_M_limit ( __pos , __n ) , size_type ( 0 ) ) ;
return * this ;
}
#1377
iterator
erase ( iterator __position )
{

;
const size_type __pos = __position - _M_ibegin ( ) ;
_M_mutate ( __pos , size_type ( 1 ) , size_type ( 0 ) ) ;
_M_rep ( ) -> _M_set_leaked ( ) ;
return iterator ( _M_data ( ) + __pos ) ;
}
#1397
iterator
erase ( iterator __first , iterator __last ) ;
#1406
void
pop_back ( )
{ erase ( size ( ) - 1 , 1 ) ; }
#1428
basic_string &
replace ( size_type __pos , size_type __n , const basic_string & __str )
{ return this -> replace ( __pos , __n , __str . _M_data ( ) , __str . size ( ) ) ; }
#1450
basic_string &
replace ( size_type __pos1 , size_type __n1 , const basic_string & __str ,
size_type __pos2 , size_type __n2 )
{ return this -> replace ( __pos1 , __n1 , __str . _M_data ( )
+ __str . _M_check ( __pos2 , "basic_string::replace" ) ,
__str . _M_limit ( __pos2 , __n2 ) ) ; }
#1475
basic_string &
replace ( size_type __pos , size_type __n1 , const _CharT * __s ,
size_type __n2 ) ;
#1495
basic_string &
replace ( size_type __pos , size_type __n1 , const _CharT * __s )
{
;
return this -> replace ( __pos , __n1 , __s , traits_type :: length ( __s ) ) ;
}
#1519
basic_string &
replace ( size_type __pos , size_type __n1 , size_type __n2 , _CharT __c )
{ return _M_replace_aux ( _M_check ( __pos , "basic_string::replace" ) ,
_M_limit ( __pos , __n1 ) , __n2 , __c ) ; }
#1537
basic_string &
replace ( iterator __i1 , iterator __i2 , const basic_string & __str )
{ return this -> replace ( __i1 , __i2 , __str . _M_data ( ) , __str . size ( ) ) ; }
#1556
basic_string &
replace ( iterator __i1 , iterator __i2 , const _CharT * __s , size_type __n )
{

;
return this -> replace ( __i1 - _M_ibegin ( ) , __i2 - __i1 , __s , __n ) ;
}
#1577
basic_string &
replace ( iterator __i1 , iterator __i2 , const _CharT * __s )
{
;
return this -> replace ( __i1 , __i2 , __s , traits_type :: length ( __s ) ) ;
}
#1598
basic_string &
replace ( iterator __i1 , iterator __i2 , size_type __n , _CharT __c )
{

;
return _M_replace_aux ( __i1 - _M_ibegin ( ) , __i2 - __i1 , __n , __c ) ;
}
#1621
template < class _InputIterator >
basic_string &
replace ( iterator __i1 , iterator __i2 ,
_InputIterator __k1 , _InputIterator __k2 )
{

;
;
typedef typename std :: __is_integer < _InputIterator > :: __type _Integral ;
return _M_replace_dispatch ( __i1 , __i2 , __k1 , __k2 , _Integral ( ) ) ;
}



basic_string &
replace ( iterator __i1 , iterator __i2 , _CharT * __k1 , _CharT * __k2 )
{

;
;
return this -> replace ( __i1 - _M_ibegin ( ) , __i2 - __i1 ,
__k1 , __k2 - __k1 ) ;
}

basic_string &
replace ( iterator __i1 , iterator __i2 ,
const _CharT * __k1 , const _CharT * __k2 )
{

;
;
return this -> replace ( __i1 - _M_ibegin ( ) , __i2 - __i1 ,
__k1 , __k2 - __k1 ) ;
}

basic_string &
replace ( iterator __i1 , iterator __i2 , iterator __k1 , iterator __k2 )
{

;
;
return this -> replace ( __i1 - _M_ibegin ( ) , __i2 - __i1 ,
__k1 . base ( ) , __k2 - __k1 ) ;
}

basic_string &
replace ( iterator __i1 , iterator __i2 ,
const_iterator __k1 , const_iterator __k2 )
{

;
;
return this -> replace ( __i1 - _M_ibegin ( ) , __i2 - __i1 ,
__k1 . base ( ) , __k2 - __k1 ) ;
}
#1692
basic_string & replace ( iterator __i1 , iterator __i2 ,
initializer_list < _CharT > __l )
{ return this -> replace ( __i1 , __i2 , __l . begin ( ) , __l . end ( ) ) ; }


private :
template < class _Integer >
basic_string &
_M_replace_dispatch ( iterator __i1 , iterator __i2 , _Integer __n ,
_Integer __val , __true_type )
{ return _M_replace_aux ( __i1 - _M_ibegin ( ) , __i2 - __i1 , __n , __val ) ; }

template < class _InputIterator >
basic_string &
_M_replace_dispatch ( iterator __i1 , iterator __i2 , _InputIterator __k1 ,
_InputIterator __k2 , __false_type ) ;

basic_string &
_M_replace_aux ( size_type __pos1 , size_type __n1 , size_type __n2 ,
_CharT __c ) ;

basic_string &
_M_replace_safe ( size_type __pos1 , size_type __n1 , const _CharT * __s ,
size_type __n2 ) ;



template < class _InIterator >
static _CharT *
_S_construct_aux ( _InIterator __beg , _InIterator __end ,
const _Alloc & __a , __false_type )
{
typedef typename iterator_traits < _InIterator > :: iterator_category _Tag ;
return _S_construct ( __beg , __end , __a , _Tag ( ) ) ;
}



template < class _Integer >
static _CharT *
_S_construct_aux ( _Integer __beg , _Integer __end ,
const _Alloc & __a , __true_type )
{ return _S_construct_aux_2 ( static_cast < size_type > ( __beg ) ,
__end , __a ) ; }

static _CharT *
_S_construct_aux_2 ( size_type __req , _CharT __c , const _Alloc & __a )
{ return _S_construct ( __req , __c , __a ) ; }

template < class _InIterator >
static _CharT *
_S_construct ( _InIterator __beg , _InIterator __end , const _Alloc & __a )
{
typedef typename std :: __is_integer < _InIterator > :: __type _Integral ;
return _S_construct_aux ( __beg , __end , __a , _Integral ( ) ) ;
}


template < class _InIterator >
static _CharT *
_S_construct ( _InIterator __beg , _InIterator __end , const _Alloc & __a ,
input_iterator_tag ) ;



template < class _FwdIterator >
static _CharT *
_S_construct ( _FwdIterator __beg , _FwdIterator __end , const _Alloc & __a ,
forward_iterator_tag ) ;

static _CharT *
_S_construct ( size_type __req , _CharT __c , const _Alloc & __a ) ;

public :
#1779
size_type
copy ( _CharT * __s , size_type __n , size_type __pos = 0 ) const ;
#1789
void
swap ( basic_string & __s ) ;
#1799
const _CharT *
c_str ( ) const noexcept
{ return _M_data ( ) ; }
#1809
const _CharT *
data ( ) const noexcept
{ return _M_data ( ) ; }




allocator_type
get_allocator ( ) const noexcept
{ return _M_dataplus ; }
#1832
size_type
find ( const _CharT * __s , size_type __pos , size_type __n ) const ;
#1845
size_type
find ( const basic_string & __str , size_type __pos = 0 ) const
noexcept
{ return this -> find ( __str . data ( ) , __pos , __str . size ( ) ) ; }
#1860
size_type
find ( const _CharT * __s , size_type __pos = 0 ) const
{
;
return this -> find ( __s , __pos , traits_type :: length ( __s ) ) ;
}
#1877
size_type
find ( _CharT __c , size_type __pos = 0 ) const noexcept ;
#1890
size_type
rfind ( const basic_string & __str , size_type __pos = npos ) const
noexcept
{ return this -> rfind ( __str . data ( ) , __pos , __str . size ( ) ) ; }
#1907
size_type
rfind ( const _CharT * __s , size_type __pos , size_type __n ) const ;
#1920
size_type
rfind ( const _CharT * __s , size_type __pos = npos ) const
{
;
return this -> rfind ( __s , __pos , traits_type :: length ( __s ) ) ;
}
#1937
size_type
rfind ( _CharT __c , size_type __pos = npos ) const noexcept ;
#1951
size_type
find_first_of ( const basic_string & __str , size_type __pos = 0 ) const
noexcept
{ return this -> find_first_of ( __str . data ( ) , __pos , __str . size ( ) ) ; }
#1968
size_type
find_first_of ( const _CharT * __s , size_type __pos , size_type __n ) const ;
#1981
size_type
find_first_of ( const _CharT * __s , size_type __pos = 0 ) const
{
;
return this -> find_first_of ( __s , __pos , traits_type :: length ( __s ) ) ;
}
#2000
size_type
find_first_of ( _CharT __c , size_type __pos = 0 ) const noexcept
{ return this -> find ( __c , __pos ) ; }
#2015
size_type
find_last_of ( const basic_string & __str , size_type __pos = npos ) const
noexcept
{ return this -> find_last_of ( __str . data ( ) , __pos , __str . size ( ) ) ; }
#2032
size_type
find_last_of ( const _CharT * __s , size_type __pos , size_type __n ) const ;
#2045
size_type
find_last_of ( const _CharT * __s , size_type __pos = npos ) const
{
;
return this -> find_last_of ( __s , __pos , traits_type :: length ( __s ) ) ;
}
#2064
size_type
find_last_of ( _CharT __c , size_type __pos = npos ) const noexcept
{ return this -> rfind ( __c , __pos ) ; }
#2078
size_type
find_first_not_of ( const basic_string & __str , size_type __pos = 0 ) const
noexcept
{ return this -> find_first_not_of ( __str . data ( ) , __pos , __str . size ( ) ) ; }
#2095
size_type
find_first_not_of ( const _CharT * __s , size_type __pos ,
size_type __n ) const ;
#2109
size_type
find_first_not_of ( const _CharT * __s , size_type __pos = 0 ) const
{
;
return this -> find_first_not_of ( __s , __pos , traits_type :: length ( __s ) ) ;
}
#2126
size_type
find_first_not_of ( _CharT __c , size_type __pos = 0 ) const
noexcept ;
#2141
size_type
find_last_not_of ( const basic_string & __str , size_type __pos = npos ) const
noexcept
{ return this -> find_last_not_of ( __str . data ( ) , __pos , __str . size ( ) ) ; }
#2158
size_type
find_last_not_of ( const _CharT * __s , size_type __pos ,
size_type __n ) const ;
#2172
size_type
find_last_not_of ( const _CharT * __s , size_type __pos = npos ) const
{
;
return this -> find_last_not_of ( __s , __pos , traits_type :: length ( __s ) ) ;
}
#2189
size_type
find_last_not_of ( _CharT __c , size_type __pos = npos ) const
noexcept ;
#2205
basic_string
substr ( size_type __pos = 0 , size_type __n = npos ) const
{ return basic_string ( * this ,
_M_check ( __pos , "basic_string::substr" ) , __n ) ; }
#2224
int
compare ( const basic_string & __str ) const
{
const size_type __size = this -> size ( ) ;
const size_type __osize = __str . size ( ) ;
const size_type __len = std :: min ( __size , __osize ) ;

int __r = traits_type :: compare ( _M_data ( ) , __str . data ( ) , __len ) ;
if ( ! __r )
__r = _S_compare ( __size , __osize ) ;
return __r ;
}
#2256
int
compare ( size_type __pos , size_type __n , const basic_string & __str ) const ;
#2282
int
compare ( size_type __pos1 , size_type __n1 , const basic_string & __str ,
size_type __pos2 , size_type __n2 ) const ;
#2300
int
compare ( const _CharT * __s ) const ;
#2324
int
compare ( size_type __pos , size_type __n1 , const _CharT * __s ) const ;
#2351
int
compare ( size_type __pos , size_type __n1 , const _CharT * __s ,
size_type __n2 ) const ;
} ;
#2363
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 ;
}
#2379
template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc >
operator + ( const _CharT * __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs ) ;
#2390
template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc >
operator + ( _CharT __lhs , const basic_string < _CharT , _Traits , _Alloc > & __rhs ) ;
#2400
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 ;
}
#2416
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 basic_string < _CharT , _Traits , _Alloc >
operator + ( basic_string < _CharT , _Traits , _Alloc > && __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return std :: move ( __lhs . append ( __rhs ) ) ; }

template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_string < _CharT , _Traits , _Alloc >
operator + ( const basic_string < _CharT , _Traits , _Alloc > & __lhs ,
basic_string < _CharT , _Traits , _Alloc > && __rhs )
{ return std :: move ( __rhs . insert ( 0 , __lhs ) ) ; }

template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_string < _CharT , _Traits , _Alloc >
operator + ( basic_string < _CharT , _Traits , _Alloc > && __lhs ,
basic_string < _CharT , _Traits , _Alloc > && __rhs )
{
const auto __size = __lhs . size ( ) + __rhs . size ( ) ;
const bool __cond = ( __size > __lhs . capacity ( )
&& __size <= __rhs . capacity ( ) ) ;
return __cond ? std :: move ( __rhs . insert ( 0 , __lhs ) )
: std :: move ( __lhs . append ( __rhs ) ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_string < _CharT , _Traits , _Alloc >
operator + ( const _CharT * __lhs ,
basic_string < _CharT , _Traits , _Alloc > && __rhs )
{ return std :: move ( __rhs . insert ( 0 , __lhs ) ) ; }

template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_string < _CharT , _Traits , _Alloc >
operator + ( _CharT __lhs ,
basic_string < _CharT , _Traits , _Alloc > && __rhs )
{ return std :: move ( __rhs . insert ( 0 , 1 , __lhs ) ) ; }

template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_string < _CharT , _Traits , _Alloc >
operator + ( basic_string < _CharT , _Traits , _Alloc > && __lhs ,
const _CharT * __rhs )
{ return std :: move ( __lhs . append ( __rhs ) ) ; }

template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_string < _CharT , _Traits , _Alloc >
operator + ( basic_string < _CharT , _Traits , _Alloc > && __lhs ,
_CharT __rhs )
{ return std :: move ( __lhs . append ( 1 , __rhs ) ) ; }
#2484
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator == ( const basic_string < _CharT , _Traits , _Alloc > & __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return __lhs . compare ( __rhs ) == 0 ; }

template < typename _CharT >
inline
typename __gnu_cxx :: __enable_if < __is_char < _CharT > :: __value , bool > :: __type
operator == ( const basic_string < _CharT > & __lhs ,
const basic_string < _CharT > & __rhs )
{ return ( __lhs . size ( ) == __rhs . size ( )
&& ! std :: char_traits < _CharT > :: compare ( __lhs . data ( ) , __rhs . data ( ) ,
__lhs . size ( ) ) ) ; }
#2505
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 ; }
#2517
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator == ( const basic_string < _CharT , _Traits , _Alloc > & __lhs ,
const _CharT * __rhs )
{ return __lhs . compare ( __rhs ) == 0 ; }
#2530
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator != ( const basic_string < _CharT , _Traits , _Alloc > & __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return ! ( __lhs == __rhs ) ; }
#2542
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator != ( const _CharT * __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return ! ( __lhs == __rhs ) ; }
#2554
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator != ( const basic_string < _CharT , _Traits , _Alloc > & __lhs ,
const _CharT * __rhs )
{ return ! ( __lhs == __rhs ) ; }
#2567
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 ; }
#2579
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 ; }
#2591
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator < ( const _CharT * __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return __rhs . compare ( __lhs ) > 0 ; }
#2604
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 ; }
#2616
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 ; }
#2628
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator > ( const _CharT * __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return __rhs . compare ( __lhs ) < 0 ; }
#2641
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 ; }
#2653
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 ; }
#2665
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator <= ( const _CharT * __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return __rhs . compare ( __lhs ) >= 0 ; }
#2678
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 ; }
#2690
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 ; }
#2702
template < typename _CharT , typename _Traits , typename _Alloc >
inline bool
operator >= ( const _CharT * __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ return __rhs . compare ( __lhs ) <= 0 ; }
#2715
template < typename _CharT , typename _Traits , typename _Alloc >
inline void
swap ( basic_string < _CharT , _Traits , _Alloc > & __lhs ,
basic_string < _CharT , _Traits , _Alloc > & __rhs )
{ __lhs . swap ( __rhs ) ; }
#2733
template < typename _CharT , typename _Traits , typename _Alloc >
basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > & __is ,
basic_string < _CharT , _Traits , _Alloc > & __str ) ;

template < >
basic_istream < char > &
operator >> ( basic_istream < char > & __is , basic_string < char > & __str ) ;
#2751
template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > & __os ,
const basic_string < _CharT , _Traits , _Alloc > & __str )
{


return __ostream_insert ( __os , __str . data ( ) , __str . size ( ) ) ;
}
#2774
template < typename _CharT , typename _Traits , typename _Alloc >
basic_istream < _CharT , _Traits > &
getline ( basic_istream < _CharT , _Traits > & __is ,
basic_string < _CharT , _Traits , _Alloc > & __str , _CharT __delim ) ;
#2791
template < typename _CharT , typename _Traits , typename _Alloc >
inline basic_istream < _CharT , _Traits > &
getline ( basic_istream < _CharT , _Traits > & __is ,
basic_string < _CharT , _Traits , _Alloc > & __str )
{ return getline ( __is , __str , __is . widen ( '\n' ) ) ; }

template < >
basic_istream < char > &
getline ( basic_istream < char > & __in , basic_string < char > & __str ,
char __delim ) ;


template < >
basic_istream < wchar_t > &
getline ( basic_istream < wchar_t > & __in , basic_string < wchar_t > & __str ,
wchar_t __delim ) ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/string_conversions.h"
#32
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cerrno"
#39
#pragma GCC system_header
#1 "/usr/include/errno.h"
#17
#pragma ident "@(#)errno.h  1.17    03/01/03 SMI"
#1 "/usr/include/sys/errno.h"
#9
#pragma ident "@(#)errno.h  1.20    00/01/12 SMI"
#40
extern "C" {
#197
}
#26 "/usr/include/errno.h"
extern "C" {
#37
extern int * ___errno ( ) ;
#48
}
#46 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/string_conversions.h"
namespace __gnu_cxx
{



template < typename _TRet , typename _Ret = _TRet , typename _CharT ,
typename ... _Base >
_Ret
__stoa ( _TRet ( * __convf ) ( const _CharT * , _CharT * * , _Base ... ) ,
const char * __name , const _CharT * __str , std :: size_t * __idx ,
_Base ... __base )
{
_Ret __ret ;

_CharT * __endptr ;
( * ( ___errno ( ) ) ) = 0 ;
const _TRet __tmp = __convf ( __str , & __endptr , __base ... ) ;

if ( __endptr == __str )
std :: __throw_invalid_argument ( __name ) ;
else if ( ( * ( ___errno ( ) ) ) == 34
|| ( std :: __are_same < _Ret , int > :: __value
&& ( __tmp < __numeric_traits < int > :: __min
|| __tmp > __numeric_traits < int > :: __max ) ) )
std :: __throw_out_of_range ( __name ) ;
else
__ret = __tmp ;

if ( __idx )
* __idx = __endptr - __str ;

return __ret ;
}


template < typename _String , typename _CharT = typename _String :: value_type >
_String
__to_xstring ( int ( * __convf ) ( _CharT * , std :: size_t , const _CharT * ,
__builtin_va_list ) , std :: size_t __n ,
const _CharT * __fmt , ... )
{


_CharT * __s = static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* __n ) ) ;

__builtin_va_list __args ;
__builtin_va_start ( __args , __fmt ) ;

const int __len = __convf ( __s , __n , __fmt , __args ) ;

( ( void ) 0 ) ;

return _String ( __s , __s + __len ) ;
}


}
#2817 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_string.h"
namespace std
{



inline int
stoi ( const string & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa < long , int > ( & std :: strtol , "stoi" , __str . c_str ( ) ,
__idx , __base ) ; }

inline long
stol ( const string & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: strtol , "stol" , __str . c_str ( ) ,
__idx , __base ) ; }

inline unsigned long
stoul ( const string & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: strtoul , "stoul" , __str . c_str ( ) ,
__idx , __base ) ; }

inline long long
stoll ( const string & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: strtoll , "stoll" , __str . c_str ( ) ,
__idx , __base ) ; }

inline unsigned long long
stoull ( const string & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: strtoull , "stoull" , __str . c_str ( ) ,
__idx , __base ) ; }


inline float
stof ( const string & __str , size_t * __idx = 0 )
{ return __gnu_cxx :: __stoa ( & std :: strtof , "stof" , __str . c_str ( ) , __idx ) ; }

inline double
stod ( const string & __str , size_t * __idx = 0 )
{ return __gnu_cxx :: __stoa ( & std :: strtod , "stod" , __str . c_str ( ) , __idx ) ; }

inline long double
stold ( const string & __str , size_t * __idx = 0 )
{ return __gnu_cxx :: __stoa ( & std :: strtold , "stold" , __str . c_str ( ) , __idx ) ; }




inline string
to_string ( int __val )
{ return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf , 4 * sizeof ( int ) ,
"%d" , __val ) ; }

inline string
to_string ( unsigned __val )
{ return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf ,
4 * sizeof ( unsigned ) ,
"%u" , __val ) ; }

inline string
to_string ( long __val )
{ return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf , 4 * sizeof ( long ) ,
"%ld" , __val ) ; }

inline string
to_string ( unsigned long __val )
{ return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf ,
4 * sizeof ( unsigned long ) ,
"%lu" , __val ) ; }

inline string
to_string ( long long __val )
{ return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf ,
4 * sizeof ( long long ) ,
"%lld" , __val ) ; }

inline string
to_string ( unsigned long long __val )
{ return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf ,
4 * sizeof ( unsigned long long ) ,
"%llu" , __val ) ; }

inline string
to_string ( float __val )
{
const int __n =
__gnu_cxx :: __numeric_traits < float > :: __max_exponent10 + 20 ;
return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf , __n ,
"%f" , __val ) ;
}

inline string
to_string ( double __val )
{
const int __n =
__gnu_cxx :: __numeric_traits < double > :: __max_exponent10 + 20 ;
return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf , __n ,
"%f" , __val ) ;
}

inline string
to_string ( long double __val )
{
const int __n =
__gnu_cxx :: __numeric_traits < long double > :: __max_exponent10 + 20 ;
return __gnu_cxx :: __to_xstring < string > ( & std :: vsnprintf , __n ,
"%Lf" , __val ) ;
}


inline int
stoi ( const wstring & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa < long , int > ( & std :: wcstol , "stoi" , __str . c_str ( ) ,
__idx , __base ) ; }

inline long
stol ( const wstring & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: wcstol , "stol" , __str . c_str ( ) ,
__idx , __base ) ; }

inline unsigned long
stoul ( const wstring & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: wcstoul , "stoul" , __str . c_str ( ) ,
__idx , __base ) ; }

inline long long
stoll ( const wstring & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: wcstoll , "stoll" , __str . c_str ( ) ,
__idx , __base ) ; }

inline unsigned long long
stoull ( const wstring & __str , size_t * __idx = 0 , int __base = 10 )
{ return __gnu_cxx :: __stoa ( & std :: wcstoull , "stoull" , __str . c_str ( ) ,
__idx , __base ) ; }


inline float
stof ( const wstring & __str , size_t * __idx = 0 )
{ return __gnu_cxx :: __stoa ( & std :: wcstof , "stof" , __str . c_str ( ) , __idx ) ; }

inline double
stod ( const wstring & __str , size_t * __idx = 0 )
{ return __gnu_cxx :: __stoa ( & std :: wcstod , "stod" , __str . c_str ( ) , __idx ) ; }

inline long double
stold ( const wstring & __str , size_t * __idx = 0 )
{ return __gnu_cxx :: __stoa ( & std :: wcstold , "stold" , __str . c_str ( ) , __idx ) ; }


inline wstring
to_wstring ( int __val )
{ return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf , 4 * sizeof ( int ) ,
L"%d" , __val ) ; }

inline wstring
to_wstring ( unsigned __val )
{ return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf ,
4 * sizeof ( unsigned ) ,
L"%u" , __val ) ; }

inline wstring
to_wstring ( long __val )
{ return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf , 4 * sizeof ( long ) ,
L"%ld" , __val ) ; }

inline wstring
to_wstring ( unsigned long __val )
{ return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf ,
4 * sizeof ( unsigned long ) ,
L"%lu" , __val ) ; }

inline wstring
to_wstring ( long long __val )
{ return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf ,
4 * sizeof ( long long ) ,
L"%lld" , __val ) ; }

inline wstring
to_wstring ( unsigned long long __val )
{ return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf ,
4 * sizeof ( unsigned long long ) ,
L"%llu" , __val ) ; }

inline wstring
to_wstring ( float __val )
{
const int __n =
__gnu_cxx :: __numeric_traits < float > :: __max_exponent10 + 20 ;
return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf , __n ,
L"%f" , __val ) ;
}

inline wstring
to_wstring ( double __val )
{
const int __n =
__gnu_cxx :: __numeric_traits < double > :: __max_exponent10 + 20 ;
return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf , __n ,
L"%f" , __val ) ;
}

inline wstring
to_wstring ( long double __val )
{
const int __n =
__gnu_cxx :: __numeric_traits < long double > :: __max_exponent10 + 20 ;
return __gnu_cxx :: __to_xstring < wstring > ( & std :: vswprintf , __n ,
L"%Lf" , __val ) ;
}



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/functional_hash.h"
#33
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/hash_bytes.h"
#33
#pragma GCC system_header
#37
namespace std
{
#46
size_t
_Hash_bytes ( const void * __ptr , size_t __len , size_t __seed ) ;





size_t
_Fnv_hash_bytes ( const void * __ptr , size_t __len , size_t __seed ) ;


}
#37 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/functional_hash.h"
namespace std
{
#49
template < typename _Result , typename _Arg >
struct __hash_base
{
typedef _Result result_type ;
typedef _Arg argument_type ;
} ;


template < typename _Tp >
struct hash ;


template < typename _Tp >
struct hash < _Tp * > : public __hash_base < size_t , _Tp * >
{
size_t
operator ( ) ( _Tp * __p ) const noexcept
{ return reinterpret_cast < size_t > ( __p ) ; }
} ;
#80
template < > struct hash < bool > : public __hash_base < size_t , bool > { size_t operator ( ) ( bool __val ) const noexcept
#80
{ return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < char > : public __hash_base < size_t , char > { size_t operator ( ) ( char __val ) const noexcept
#83
{ return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < signed char > : public __hash_base < size_t , signed char > { size_t operator ( ) ( signed char
#86
__val ) const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < unsigned char > : public __hash_base < size_t , unsigned char > { size_t operator ( ) ( unsigned
#89
char __val ) const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < wchar_t > : public __hash_base < size_t , wchar_t > { size_t operator ( ) ( wchar_t __val ) const
#92
noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < char16_t > : public __hash_base < size_t , char16_t > { size_t operator ( ) ( char16_t __val )
#95
const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < char32_t > : public __hash_base < size_t , char32_t > { size_t operator ( ) ( char32_t __val )
#98
const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < short > : public __hash_base < size_t , short > { size_t operator ( ) ( short __val ) const noexcept
#101
{ return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < int > : public __hash_base < size_t , int > { size_t operator ( ) ( int __val ) const noexcept
#104
{ return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < long > : public __hash_base < size_t , long > { size_t operator ( ) ( long __val ) const noexcept
#107
{ return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < long long > : public __hash_base < size_t , long long > { size_t operator ( ) ( long long __val
#110
) const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < unsigned short > : public __hash_base < size_t , unsigned short > { size_t operator ( ) ( unsigned
#113
short __val ) const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < unsigned int > : public __hash_base < size_t , unsigned int > { size_t operator ( ) ( unsigned
#116
int __val ) const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < unsigned long > : public __hash_base < size_t , unsigned long > { size_t operator ( ) ( unsigned
#119
long __val ) const noexcept { return static_cast < size_t > ( __val ) ; } } ;


template < > struct hash < unsigned long long > : public __hash_base < size_t , unsigned long long > { size_t operator (
#122
) ( unsigned long long __val ) const noexcept { return static_cast < size_t > ( __val ) ; } } ;



struct _Hash_impl
{
static size_t
hash ( const void * __ptr , size_t __clength ,
size_t __seed = static_cast < size_t > ( 0xc70f6907UL ) )
{ return _Hash_bytes ( __ptr , __clength , __seed ) ; }

template < typename _Tp >
static size_t
hash ( const _Tp & __val )
{ return hash ( & __val , sizeof ( __val ) ) ; }

template < typename _Tp >
static size_t
__hash_combine ( const _Tp & __val , size_t __hash )
{ return hash ( & __val , sizeof ( __val ) , __hash ) ; }
} ;

struct _Fnv_hash_impl
{
static size_t
hash ( const void * __ptr , size_t __clength ,
size_t __seed = static_cast < size_t > ( 2166136261UL ) )
{ return _Fnv_hash_bytes ( __ptr , __clength , __seed ) ; }

template < typename _Tp >
static size_t
hash ( const _Tp & __val )
{ return hash ( & __val , sizeof ( __val ) ) ; }

template < typename _Tp >
static size_t
__hash_combine ( const _Tp & __val , size_t __hash )
{ return hash ( & __val , sizeof ( __val ) , __hash ) ; }
} ;


template < >
struct hash < float > : public __hash_base < size_t , float >
{
size_t
operator ( ) ( float __val ) const noexcept
{

return __val != 0.0f ? std :: _Hash_impl :: hash ( __val ) : 0 ;
}
} ;


template < >
struct hash < double > : public __hash_base < size_t , double >
{
size_t
operator ( ) ( double __val ) const noexcept
{

return __val != 0.0 ? std :: _Hash_impl :: hash ( __val ) : 0 ;
}
} ;


template < >
struct hash < long double >
: public __hash_base < size_t , long double >
{
__attribute__ ( ( __pure__ ) ) size_t
operator ( ) ( long double __val ) const noexcept ;
} ;
#201
template < typename _Hash >
struct __is_fast_hash : public std :: true_type
{ } ;

template < >
struct __is_fast_hash < hash < long double >> : public std :: false_type
{ } ;


}
#3035 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_string.h"
namespace std
{
#3043
template < >
struct hash < string >
: public __hash_base < size_t , string >
{
size_t
operator ( ) ( const string & __s ) const noexcept
{ return std :: _Hash_impl :: hash ( __s . data ( ) , __s . length ( ) ) ; }
} ;

template < >
struct __is_fast_hash < hash < string >> : std :: false_type
{ } ;



template < >
struct hash < wstring >
: public __hash_base < size_t , wstring >
{
size_t
operator ( ) ( const wstring & __s ) const noexcept
{ return std :: _Hash_impl :: hash ( __s . data ( ) ,
__s . length ( ) * sizeof ( wchar_t ) ) ; }
} ;

template < >
struct __is_fast_hash < hash < wstring >> : std :: false_type
{ } ;





template < >
struct hash < u16string >
: public __hash_base < size_t , u16string >
{
size_t
operator ( ) ( const u16string & __s ) const noexcept
{ return std :: _Hash_impl :: hash ( __s . data ( ) ,
__s . length ( ) * sizeof ( char16_t ) ) ; }
} ;

template < >
struct __is_fast_hash < hash < u16string >> : std :: false_type
{ } ;


template < >
struct hash < u32string >
: public __hash_base < size_t , u32string >
{
size_t
operator ( ) ( const u32string & __s ) const noexcept
{ return std :: _Hash_impl :: hash ( __s . data ( ) ,
__s . length ( ) * sizeof ( char32_t ) ) ; }
} ;

template < >
struct __is_fast_hash < hash < u32string >> : std :: false_type
{ } ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_string.tcc"
#40
#pragma GCC system_header
#44
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_base ) ) / sizeof ( _CharT ) ) - 1 ) / 4 ;

template < typename _CharT , typename _Traits , typename _Alloc >
const _CharT
basic_string < _CharT , _Traits , _Alloc > ::
_Rep :: _S_terminal = _CharT ( ) ;

template < typename _CharT , typename _Traits , typename _Alloc >
const typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > :: npos ;



template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > :: _Rep :: _S_empty_rep_storage [
( sizeof ( _Rep_base ) + sizeof ( _CharT ) + sizeof ( size_type ) - 1 ) /
sizeof ( size_type ) ] ;





template < typename _CharT , typename _Traits , typename _Alloc >
template < typename _InIterator >
_CharT *
basic_string < _CharT , _Traits , _Alloc > ::
_S_construct ( _InIterator __beg , _InIterator __end , const _Alloc & __a ,
input_iterator_tag )
{

if ( __beg == __end && __a == _Alloc ( ) )
return _S_empty_rep ( ) . _M_refdata ( ) ;


_CharT __buf [ 128 ] ;
size_type __len = 0 ;
while ( __beg != __end && __len < sizeof ( __buf ) / sizeof ( _CharT ) )
{
__buf [ __len ++ ] = * __beg ;
++ __beg ;
}
_Rep * __r = _Rep :: _S_create ( __len , size_type ( 0 ) , __a ) ;
_M_copy ( __r -> _M_refdata ( ) , __buf , __len ) ;
try
{
while ( __beg != __end )
{
if ( __len == __r -> _M_capacity )
{

_Rep * __another = _Rep :: _S_create ( __len + 1 , __len , __a ) ;
_M_copy ( __another -> _M_refdata ( ) , __r -> _M_refdata ( ) , __len ) ;
__r -> _M_destroy ( __a ) ;
__r = __another ;
}
__r -> _M_refdata ( ) [ __len ++ ] = * __beg ;
++ __beg ;
}
}
catch ( ... )
{
__r -> _M_destroy ( __a ) ;
throw ;
}
__r -> _M_set_length_and_sharable ( __len ) ;
return __r -> _M_refdata ( ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
template < typename _InIterator >
_CharT *
basic_string < _CharT , _Traits , _Alloc > ::
_S_construct ( _InIterator __beg , _InIterator __end , const _Alloc & __a ,
forward_iterator_tag )
{

if ( __beg == __end && __a == _Alloc ( ) )
return _S_empty_rep ( ) . _M_refdata ( ) ;


if ( __gnu_cxx :: __is_null_pointer ( __beg ) && __beg != __end )
__throw_logic_error ( ( "basic_string::_S_construct null not valid" ) ) ;

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

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

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

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


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

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

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

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

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

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


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


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

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


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


template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc > ::
basic_string ( initializer_list < _CharT > __l , const _Alloc & __a )
: _M_dataplus ( _S_construct ( __l . begin ( ) , __l . end ( ) , __a ) , __a )
{ }


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

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

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

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

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

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

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

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

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

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

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: iterator
basic_string < _CharT , _Traits , _Alloc > ::
erase ( iterator __first , iterator __last )
{

;




const size_type __size = __last - __first ;
if ( __size )
{
const size_type __pos = __first - _M_ibegin ( ) ;
_M_mutate ( __pos , __size , size_type ( 0 ) ) ;
_M_rep ( ) -> _M_set_leaked ( ) ;
return iterator ( _M_data ( ) + __pos ) ;
}
else
return __first ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc > &
basic_string < _CharT , _Traits , _Alloc > ::
replace ( size_type __pos , size_type __n1 , const _CharT * __s ,
size_type __n2 )
{
;
_M_check ( __pos , "basic_string::replace" ) ;
__n1 = _M_limit ( __pos , __n1 ) ;
_M_check_length ( __n1 , __n2 , "basic_string::replace" ) ;
bool __left ;
if ( _M_disjunct ( __s ) || _M_rep ( ) -> _M_is_shared ( ) )
return _M_replace_safe ( __pos , __n1 , __s , __n2 ) ;
else if ( ( __left = __s + __n2 <= _M_data ( ) + __pos )
|| _M_data ( ) + __pos + __n1 <= __s )
{

size_type __off = __s - _M_data ( ) ;
__left ? __off : ( __off += __n2 - __n1 ) ;
_M_mutate ( __pos , __n1 , __n2 ) ;
_M_copy ( _M_data ( ) + __pos , _M_data ( ) + __off , __n2 ) ;
return * this ;
}
else
{

const basic_string __tmp ( __s , __n2 ) ;
return _M_replace_safe ( __pos , __n1 , __tmp . _M_data ( ) , __n2 ) ;
}
}

template < typename _CharT , typename _Traits , typename _Alloc >
void
basic_string < _CharT , _Traits , _Alloc > :: _Rep ::
_M_destroy ( const _Alloc & __a ) throw ( )
{
const size_type __size = sizeof ( _Rep_base ) +
( this -> _M_capacity + 1 ) * sizeof ( _CharT ) ;
_Raw_bytes_alloc ( __a ) . deallocate ( reinterpret_cast < char * > ( this ) , __size ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
void
basic_string < _CharT , _Traits , _Alloc > ::
_M_leak_hard ( )
{

if ( _M_rep ( ) == & _S_empty_rep ( ) )
return ;

if ( _M_rep ( ) -> _M_is_shared ( ) )
_M_mutate ( 0 , 0 , 0 ) ;
_M_rep ( ) -> _M_set_leaked ( ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
void
basic_string < _CharT , _Traits , _Alloc > ::
_M_mutate ( size_type __pos , size_type __len1 , size_type __len2 )
{
const size_type __old_size = this -> size ( ) ;
const size_type __new_size = __old_size + __len2 - __len1 ;
const size_type __how_much = __old_size - __pos - __len1 ;

if ( __new_size > this -> capacity ( ) || _M_rep ( ) -> _M_is_shared ( ) )
{

const allocator_type __a = get_allocator ( ) ;
_Rep * __r = _Rep :: _S_create ( __new_size , this -> capacity ( ) , __a ) ;

if ( __pos )
_M_copy ( __r -> _M_refdata ( ) , _M_data ( ) , __pos ) ;
if ( __how_much )
_M_copy ( __r -> _M_refdata ( ) + __pos + __len2 ,
_M_data ( ) + __pos + __len1 , __how_much ) ;

_M_rep ( ) -> _M_dispose ( __a ) ;
_M_data ( __r -> _M_refdata ( ) ) ;
}
else if ( __how_much && __len1 != __len2 )
{

_M_move ( _M_data ( ) + __pos + __len2 ,
_M_data ( ) + __pos + __len1 , __how_much ) ;
}
_M_rep ( ) -> _M_set_length_and_sharable ( __new_size ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
void
basic_string < _CharT , _Traits , _Alloc > ::
reserve ( size_type __res )
{
if ( __res != this -> capacity ( ) || _M_rep ( ) -> _M_is_shared ( ) )
{

if ( __res < this -> size ( ) )
__res = this -> size ( ) ;
const allocator_type __a = get_allocator ( ) ;
_CharT * __tmp = _M_rep ( ) -> _M_clone ( __a , __res - this -> size ( ) ) ;
_M_rep ( ) -> _M_dispose ( __a ) ;
_M_data ( __tmp ) ;
}
}

template < typename _CharT , typename _Traits , typename _Alloc >
void
basic_string < _CharT , _Traits , _Alloc > ::
swap ( basic_string & __s )
{
if ( _M_rep ( ) -> _M_is_leaked ( ) )
_M_rep ( ) -> _M_set_sharable ( ) ;
if ( __s . _M_rep ( ) -> _M_is_leaked ( ) )
__s . _M_rep ( ) -> _M_set_sharable ( ) ;
if ( this -> get_allocator ( ) == __s . get_allocator ( ) )
{
_CharT * __tmp = _M_data ( ) ;
_M_data ( __s . _M_data ( ) ) ;
__s . _M_data ( __tmp ) ;
}

else
{
const basic_string __tmp1 ( _M_ibegin ( ) , _M_iend ( ) ,
__s . get_allocator ( ) ) ;
const basic_string __tmp2 ( __s . _M_ibegin ( ) , __s . _M_iend ( ) ,
this -> get_allocator ( ) ) ;
* this = __tmp2 ;
__s = __tmp1 ;
}
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: _Rep *
basic_string < _CharT , _Traits , _Alloc > :: _Rep ::
_S_create ( size_type __capacity , size_type __old_capacity ,
const _Alloc & __alloc )
{


if ( __capacity > _S_max_size )
__throw_length_error ( ( "basic_string::_S_create" ) ) ;
#577
const size_type __pagesize = 4096 ;
const size_type __malloc_header_size = 4 * sizeof ( void * ) ;
#586
if ( __capacity > __old_capacity && __capacity < 2 * __old_capacity )
__capacity = 2 * __old_capacity ;




size_type __size = ( __capacity + 1 ) * sizeof ( _CharT ) + sizeof ( _Rep ) ;

const size_type __adj_size = __size + __malloc_header_size ;
if ( __adj_size > __pagesize && __capacity > __old_capacity )
{
const size_type __extra = __pagesize - __adj_size % __pagesize ;
__capacity += __extra / sizeof ( _CharT ) ;

if ( __capacity > _S_max_size )
__capacity = _S_max_size ;
__size = ( __capacity + 1 ) * sizeof ( _CharT ) + sizeof ( _Rep ) ;
}



void * __place = _Raw_bytes_alloc ( __alloc ) . allocate ( __size ) ;
_Rep * __p = new ( __place ) _Rep ;
__p -> _M_capacity = __capacity ;
#617
__p -> _M_set_sharable ( ) ;
return __p ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
_CharT *
basic_string < _CharT , _Traits , _Alloc > :: _Rep ::
_M_clone ( const _Alloc & __alloc , size_type __res )
{

const size_type __requested_cap = this -> _M_length + __res ;
_Rep * __r = _Rep :: _S_create ( __requested_cap , this -> _M_capacity ,
__alloc ) ;
if ( this -> _M_length )
_M_copy ( __r -> _M_refdata ( ) , _M_refdata ( ) , this -> _M_length ) ;

__r -> _M_set_length_and_sharable ( this -> _M_length ) ;
return __r -> _M_refdata ( ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
void
basic_string < _CharT , _Traits , _Alloc > ::
resize ( size_type __n , _CharT __c )
{
const size_type __size = this -> size ( ) ;
_M_check_length ( __size , __n , "basic_string::resize" ) ;
if ( __size < __n )
this -> append ( __n - __size , __c ) ;
else if ( __n < __size )
this -> erase ( __n ) ;

}

template < typename _CharT , typename _Traits , typename _Alloc >
template < typename _InputIterator >
basic_string < _CharT , _Traits , _Alloc > &
basic_string < _CharT , _Traits , _Alloc > ::
_M_replace_dispatch ( iterator __i1 , iterator __i2 , _InputIterator __k1 ,
_InputIterator __k2 , __false_type )
{
const basic_string __s ( __k1 , __k2 ) ;
const size_type __n1 = __i2 - __i1 ;
_M_check_length ( __n1 , __s . size ( ) , "basic_string::_M_replace_dispatch" ) ;
return _M_replace_safe ( __i1 - _M_ibegin ( ) , __n1 , __s . _M_data ( ) ,
__s . size ( ) ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc > &
basic_string < _CharT , _Traits , _Alloc > ::
_M_replace_aux ( size_type __pos1 , size_type __n1 , size_type __n2 ,
_CharT __c )
{
_M_check_length ( __n1 , __n2 , "basic_string::_M_replace_aux" ) ;
_M_mutate ( __pos1 , __n1 , __n2 ) ;
if ( __n2 )
_M_assign ( _M_data ( ) + __pos1 , __n2 , __c ) ;
return * this ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc > &
basic_string < _CharT , _Traits , _Alloc > ::
_M_replace_safe ( size_type __pos1 , size_type __n1 , const _CharT * __s ,
size_type __n2 )
{
_M_mutate ( __pos1 , __n1 , __n2 ) ;
if ( __n2 )
_M_copy ( _M_data ( ) + __pos1 , __s , __n2 ) ;
return * this ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc >
operator + ( const _CharT * __lhs ,
const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{
;
typedef basic_string < _CharT , _Traits , _Alloc > __string_type ;
typedef typename __string_type :: size_type __size_type ;
const __size_type __len = _Traits :: length ( __lhs ) ;
__string_type __str ;
__str . reserve ( __len + __rhs . size ( ) ) ;
__str . append ( __lhs , __len ) ;
__str . append ( __rhs ) ;
return __str ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
basic_string < _CharT , _Traits , _Alloc >
operator + ( _CharT __lhs , const basic_string < _CharT , _Traits , _Alloc > & __rhs )
{
typedef basic_string < _CharT , _Traits , _Alloc > __string_type ;
typedef typename __string_type :: size_type __size_type ;
__string_type __str ;
const __size_type __len = __rhs . size ( ) ;
__str . reserve ( __len + 1 ) ;
__str . append ( __size_type ( 1 ) , __lhs ) ;
__str . append ( __rhs ) ;
return __str ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
copy ( _CharT * __s , size_type __n , size_type __pos ) const
{
_M_check ( __pos , "basic_string::copy" ) ;
__n = _M_limit ( __pos , __n ) ;
;
if ( __n )
_M_copy ( __s , _M_data ( ) + __pos , __n ) ;

return __n ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find ( const _CharT * __s , size_type __pos , size_type __n ) const
{
;
const size_type __size = this -> size ( ) ;
const _CharT * __data = _M_data ( ) ;

if ( __n == 0 )
return __pos <= __size ? __pos : npos ;

if ( __n <= __size )
{
for ( ; __pos <= __size - __n ; ++ __pos )
if ( traits_type :: eq ( __data [ __pos ] , __s [ 0 ] )
&& traits_type :: compare ( __data + __pos + 1 ,
__s + 1 , __n - 1 ) == 0 )
return __pos ;
}
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find ( _CharT __c , size_type __pos ) const noexcept
{
size_type __ret = npos ;
const size_type __size = this -> size ( ) ;
if ( __pos < __size )
{
const _CharT * __data = _M_data ( ) ;
const size_type __n = __size - __pos ;
const _CharT * __p = traits_type :: find ( __data + __pos , __n , __c ) ;
if ( __p )
__ret = __p - __data ;
}
return __ret ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
rfind ( const _CharT * __s , size_type __pos , size_type __n ) const
{
;
const size_type __size = this -> size ( ) ;
if ( __n <= __size )
{
__pos = std :: min ( size_type ( __size - __n ) , __pos ) ;
const _CharT * __data = _M_data ( ) ;
do
{
if ( traits_type :: compare ( __data + __pos , __s , __n ) == 0 )
return __pos ;
}
while ( __pos -- > 0 ) ;
}
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
rfind ( _CharT __c , size_type __pos ) const noexcept
{
size_type __size = this -> size ( ) ;
if ( __size )
{
if ( -- __size > __pos )
__size = __pos ;
for ( ++ __size ; __size -- > 0 ; )
if ( traits_type :: eq ( _M_data ( ) [ __size ] , __c ) )
return __size ;
}
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find_first_of ( const _CharT * __s , size_type __pos , size_type __n ) const
{
;
for ( ; __n && __pos < this -> size ( ) ; ++ __pos )
{
const _CharT * __p = traits_type :: find ( __s , __n , _M_data ( ) [ __pos ] ) ;
if ( __p )
return __pos ;
}
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find_last_of ( const _CharT * __s , size_type __pos , size_type __n ) const
{
;
size_type __size = this -> size ( ) ;
if ( __size && __n )
{
if ( -- __size > __pos )
__size = __pos ;
do
{
if ( traits_type :: find ( __s , __n , _M_data ( ) [ __size ] ) )
return __size ;
}
while ( __size -- != 0 ) ;
}
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find_first_not_of ( const _CharT * __s , size_type __pos , size_type __n ) const
{
;
for ( ; __pos < this -> size ( ) ; ++ __pos )
if ( ! traits_type :: find ( __s , __n , _M_data ( ) [ __pos ] ) )
return __pos ;
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find_first_not_of ( _CharT __c , size_type __pos ) const noexcept
{
for ( ; __pos < this -> size ( ) ; ++ __pos )
if ( ! traits_type :: eq ( _M_data ( ) [ __pos ] , __c ) )
return __pos ;
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find_last_not_of ( const _CharT * __s , size_type __pos , size_type __n ) const
{
;
size_type __size = this -> size ( ) ;
if ( __size )
{
if ( -- __size > __pos )
__size = __pos ;
do
{
if ( ! traits_type :: find ( __s , __n , _M_data ( ) [ __size ] ) )
return __size ;
}
while ( __size -- ) ;
}
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
typename basic_string < _CharT , _Traits , _Alloc > :: size_type
basic_string < _CharT , _Traits , _Alloc > ::
find_last_not_of ( _CharT __c , size_type __pos ) const noexcept
{
size_type __size = this -> size ( ) ;
if ( __size )
{
if ( -- __size > __pos )
__size = __pos ;
do
{
if ( ! traits_type :: eq ( _M_data ( ) [ __size ] , __c ) )
return __size ;
}
while ( __size -- ) ;
}
return npos ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
int
basic_string < _CharT , _Traits , _Alloc > ::
compare ( size_type __pos , size_type __n , const basic_string & __str ) const
{
_M_check ( __pos , "basic_string::compare" ) ;
__n = _M_limit ( __pos , __n ) ;
const size_type __osize = __str . size ( ) ;
const size_type __len = std :: min ( __n , __osize ) ;
int __r = traits_type :: compare ( _M_data ( ) + __pos , __str . data ( ) , __len ) ;
if ( ! __r )
__r = _S_compare ( __n , __osize ) ;
return __r ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
int
basic_string < _CharT , _Traits , _Alloc > ::
compare ( size_type __pos1 , size_type __n1 , const basic_string & __str ,
size_type __pos2 , size_type __n2 ) const
{
_M_check ( __pos1 , "basic_string::compare" ) ;
__str . _M_check ( __pos2 , "basic_string::compare" ) ;
__n1 = _M_limit ( __pos1 , __n1 ) ;
__n2 = __str . _M_limit ( __pos2 , __n2 ) ;
const size_type __len = std :: min ( __n1 , __n2 ) ;
int __r = traits_type :: compare ( _M_data ( ) + __pos1 ,
__str . data ( ) + __pos2 , __len ) ;
if ( ! __r )
__r = _S_compare ( __n1 , __n2 ) ;
return __r ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
int
basic_string < _CharT , _Traits , _Alloc > ::
compare ( const _CharT * __s ) const
{
;
const size_type __size = this -> size ( ) ;
const size_type __osize = traits_type :: length ( __s ) ;
const size_type __len = std :: min ( __size , __osize ) ;
int __r = traits_type :: compare ( _M_data ( ) , __s , __len ) ;
if ( ! __r )
__r = _S_compare ( __size , __osize ) ;
return __r ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
int
basic_string < _CharT , _Traits , _Alloc > ::
compare ( size_type __pos , size_type __n1 , const _CharT * __s ) const
{
;
_M_check ( __pos , "basic_string::compare" ) ;
__n1 = _M_limit ( __pos , __n1 ) ;
const size_type __osize = traits_type :: length ( __s ) ;
const size_type __len = std :: min ( __n1 , __osize ) ;
int __r = traits_type :: compare ( _M_data ( ) + __pos , __s , __len ) ;
if ( ! __r )
__r = _S_compare ( __n1 , __osize ) ;
return __r ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
int
basic_string < _CharT , _Traits , _Alloc > ::
compare ( size_type __pos , size_type __n1 , const _CharT * __s ,
size_type __n2 ) const
{
;
_M_check ( __pos , "basic_string::compare" ) ;
__n1 = _M_limit ( __pos , __n1 ) ;
const size_type __len = std :: min ( __n1 , __n2 ) ;
int __r = traits_type :: compare ( _M_data ( ) + __pos , __s , __len ) ;
if ( ! __r )
__r = _S_compare ( __n1 , __n2 ) ;
return __r ;
}


template < typename _CharT , typename _Traits , typename _Alloc >
basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > & __in ,
basic_string < _CharT , _Traits , _Alloc > & __str )
{
typedef basic_istream < _CharT , _Traits > __istream_type ;
typedef basic_string < _CharT , _Traits , _Alloc > __string_type ;
typedef typename __istream_type :: ios_base __ios_base ;
typedef typename __istream_type :: int_type __int_type ;
typedef typename __string_type :: size_type __size_type ;
typedef ctype < _CharT > __ctype_type ;
typedef typename __ctype_type :: ctype_base __ctype_base ;

__size_type __extracted = 0 ;
typename __ios_base :: iostate __err = __ios_base :: goodbit ;
typename __istream_type :: sentry __cerb ( __in , false ) ;
if ( __cerb )
{
try
{

__str . erase ( ) ;
_CharT __buf [ 128 ] ;
__size_type __len = 0 ;
const streamsize __w = __in . width ( ) ;
const __size_type __n = __w > 0 ? static_cast < __size_type > ( __w )
: __str . max_size ( ) ;
const __ctype_type & __ct = use_facet < __ctype_type > ( __in . getloc ( ) ) ;
const __int_type __eof = _Traits :: eof ( ) ;
__int_type __c = __in . rdbuf ( ) -> sgetc ( ) ;

while ( __extracted < __n
&& ! _Traits :: eq_int_type ( __c , __eof )
&& ! __ct . is ( __ctype_base :: space ,
_Traits :: to_char_type ( __c ) ) )
{
if ( __len == sizeof ( __buf ) / sizeof ( _CharT ) )
{
__str . append ( __buf , sizeof ( __buf ) / sizeof ( _CharT ) ) ;
__len = 0 ;
}
__buf [ __len ++ ] = _Traits :: to_char_type ( __c ) ;
++ __extracted ;
__c = __in . rdbuf ( ) -> snextc ( ) ;
}
__str . append ( __buf , __len ) ;

if ( _Traits :: eq_int_type ( __c , __eof ) )
__err |= __ios_base :: eofbit ;
__in . width ( 0 ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
__in . _M_setstate ( __ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{



__in . _M_setstate ( __ios_base :: badbit ) ;
}
}

if ( ! __extracted )
__err |= __ios_base :: failbit ;
if ( __err )
__in . setstate ( __err ) ;
return __in ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
basic_istream < _CharT , _Traits > &
getline ( basic_istream < _CharT , _Traits > & __in ,
basic_string < _CharT , _Traits , _Alloc > & __str , _CharT __delim )
{
typedef basic_istream < _CharT , _Traits > __istream_type ;
typedef basic_string < _CharT , _Traits , _Alloc > __string_type ;
typedef typename __istream_type :: ios_base __ios_base ;
typedef typename __istream_type :: int_type __int_type ;
typedef typename __string_type :: size_type __size_type ;

__size_type __extracted = 0 ;
const __size_type __n = __str . max_size ( ) ;
typename __ios_base :: iostate __err = __ios_base :: goodbit ;
typename __istream_type :: sentry __cerb ( __in , true ) ;
if ( __cerb )
{
try
{
__str . erase ( ) ;
const __int_type __idelim = _Traits :: to_int_type ( __delim ) ;
const __int_type __eof = _Traits :: eof ( ) ;
__int_type __c = __in . rdbuf ( ) -> sgetc ( ) ;

while ( __extracted < __n
&& ! _Traits :: eq_int_type ( __c , __eof )
&& ! _Traits :: eq_int_type ( __c , __idelim ) )
{
__str += _Traits :: to_char_type ( __c ) ;
++ __extracted ;
__c = __in . rdbuf ( ) -> snextc ( ) ;
}

if ( _Traits :: eq_int_type ( __c , __eof ) )
__err |= __ios_base :: eofbit ;
else if ( _Traits :: eq_int_type ( __c , __idelim ) )
{
++ __extracted ;
__in . rdbuf ( ) -> sbumpc ( ) ;
}
else
__err |= __ios_base :: failbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
__in . _M_setstate ( __ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{



__in . _M_setstate ( __ios_base :: badbit ) ;
}
}
if ( ! __extracted )
__err |= __ios_base :: failbit ;
if ( __err )
__in . setstate ( __err ) ;
return __in ;
}




extern template class basic_string < char > ;
extern template
basic_istream < char > &
operator >> ( basic_istream < char > & , string & ) ;
extern template
basic_ostream < char > &
operator << ( basic_ostream < char > & , const string & ) ;
extern template
basic_istream < char > &
getline ( basic_istream < char > & , string & , char ) ;
extern template
basic_istream < char > &
getline ( basic_istream < char > & , string & ) ;


extern template class basic_string < wchar_t > ;
extern template
basic_istream < wchar_t > &
operator >> ( basic_istream < wchar_t > & , wstring & ) ;
extern template
basic_ostream < wchar_t > &
operator << ( basic_ostream < wchar_t > & , const wstring & ) ;
extern template
basic_istream < wchar_t > &
getline ( basic_istream < wchar_t > & , wstring & , wchar_t ) ;
extern template
basic_istream < wchar_t > &
getline ( basic_istream < wchar_t > & , wstring & ) ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/stdexcept"
#36
#pragma GCC system_header
#41
namespace std
{
#55
class logic_error : public exception
{
string _M_msg ;

public :

explicit
logic_error ( const string & __arg ) ;

virtual ~ logic_error ( ) noexcept ;



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



class domain_error : public logic_error
{
public :
explicit domain_error ( const string & __arg ) ;
virtual ~ domain_error ( ) noexcept ;
} ;


class invalid_argument : public logic_error
{
public :
explicit invalid_argument ( const string & __arg ) ;
virtual ~ invalid_argument ( ) noexcept ;
} ;



class length_error : public logic_error
{
public :
explicit length_error ( const string & __arg ) ;
virtual ~ length_error ( ) noexcept ;
} ;



class out_of_range : public logic_error
{
public :
explicit out_of_range ( const string & __arg ) ;
virtual ~ out_of_range ( ) noexcept ;
} ;
#112
class runtime_error : public exception
{
string _M_msg ;

public :

explicit
runtime_error ( const string & __arg ) ;

virtual ~ runtime_error ( ) noexcept ;



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


class range_error : public runtime_error
{
public :
explicit range_error ( const string & __arg ) ;
virtual ~ range_error ( ) noexcept ;
} ;


class overflow_error : public runtime_error
{
public :
explicit overflow_error ( const string & __arg ) ;
virtual ~ overflow_error ( ) noexcept ;
} ;


class underflow_error : public runtime_error
{
public :
explicit underflow_error ( const string & __arg ) ;
virtual ~ underflow_error ( ) noexcept ;
} ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/iterator"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ostream"
#36
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ios"
#36
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/ios_base.h"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_classes.h"
#37
#pragma GCC system_header
#43
namespace std
{
#62
class locale
{
public :


typedef int category ;


class facet ;
class id ;
class _Impl ;

friend class facet ;
friend class _Impl ;

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

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

template < typename _Cache >
friend struct __use_cache ;
#98
static const category none = 0 ;
static const category ctype = 1L << 0 ;
static const category numeric = 1L << 1 ;
static const category collate = 1L << 2 ;
static const category time = 1L << 3 ;
static const category monetary = 1L << 4 ;
static const category messages = 1L << 5 ;
static const category all = ( ctype | numeric | collate |
time | monetary | messages ) ;
#117
locale ( ) throw ( ) ;
#126
locale ( const locale & __other ) throw ( ) ;
#136
explicit
locale ( const char * __s ) ;
#151
locale ( const locale & __base , const char * __s , category __cat ) ;
#164
locale ( const locale & __base , const locale & __add , category __cat ) ;
#177
template < typename _Facet >
locale ( const locale & __other , _Facet * __f ) ;


~ locale ( ) throw ( ) ;
#191
const locale &
operator = ( const locale & __other ) throw ( ) ;
#206
template < typename _Facet >
locale
combine ( const locale & __other ) const ;
#215
string
name ( ) const ;
#225
bool
operator == ( const locale & __other ) const throw ( ) ;
#234
bool
operator != ( const locale & __other ) const throw ( )
{ return ! ( this -> operator == ( __other ) ) ; }
#253
template < typename _Char , typename _Traits , typename _Alloc >
bool
operator ( ) ( const basic_string < _Char , _Traits , _Alloc > & __s1 ,
const basic_string < _Char , _Traits , _Alloc > & __s2 ) const ;
#269
static locale
global ( const locale & __loc ) ;




static const locale &
classic ( ) ;

private :

_Impl * _M_impl ;


static _Impl * _S_classic ;


static _Impl * _S_global ;





static const char * const * const _S_categories ;
#304
enum { _S_categories_size = 6 + 0 } ;


static __gthread_once_t _S_once ;


explicit
locale ( _Impl * ) throw ( ) ;

static void
_S_initialize ( ) ;

static void
_S_initialize_once ( ) throw ( ) ;

static category
_S_normalize_category ( category ) ;

void
_M_coalesce ( const locale & __base , const locale & __add , category __cat ) ;
} ;
#338
class locale :: facet
{
private :
friend class locale ;
friend class locale :: _Impl ;

mutable _Atomic_word _M_refcount ;


static __c_locale _S_c_locale ;


static const char _S_c_name [ 2 ] ;


static __gthread_once_t _S_once ;


static void
_S_initialize_once ( ) ;

protected :
#369
explicit
facet ( size_t __refs = 0 ) throw ( ) : _M_refcount ( __refs ? 1 : 0 )
{ }


virtual
~ facet ( ) ;

static void
_S_create_c_locale ( __c_locale & __cloc , const char * __s ,
__c_locale __old = 0 ) ;

static __c_locale
_S_clone_c_locale ( __c_locale & __cloc ) throw ( ) ;

static void
_S_destroy_c_locale ( __c_locale & __cloc ) ;

static __c_locale
_S_lc_ctype_c_locale ( __c_locale __cloc , const char * __s ) ;



static __c_locale
_S_get_c_locale ( ) ;

__attribute__ ( ( __const__ ) ) static const char *
_S_get_c_name ( ) throw ( ) ;

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

void
_M_remove_reference ( ) const throw ( )
{

;
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & _M_refcount , - 1 ) == 1 )
{
;
try
{ delete this ; }
catch ( ... )
{ }
}
}

facet ( const facet & ) ;

facet &
operator = ( const facet & ) ;
} ;
#436
class locale :: id
{
private :
friend class locale ;
friend class locale :: _Impl ;

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

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




mutable size_t _M_index ;


static _Atomic_word _S_refcount ;

void
operator = ( const id & ) ;

id ( const id & ) ;

public :



id ( ) { }

size_t
_M_id ( ) const throw ( ) ;
} ;



class locale :: _Impl
{
public :

friend class locale ;
friend class locale :: facet ;

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

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

template < typename _Cache >
friend struct __use_cache ;

private :

_Atomic_word _M_refcount ;
const facet * * _M_facets ;
size_t _M_facets_size ;
const facet * * _M_caches ;
char * * _M_names ;
static const locale :: id * const _S_id_ctype [ ] ;
static const locale :: id * const _S_id_numeric [ ] ;
static const locale :: id * const _S_id_collate [ ] ;
static const locale :: id * const _S_id_time [ ] ;
static const locale :: id * const _S_id_monetary [ ] ;
static const locale :: id * const _S_id_messages [ ] ;
static const locale :: id * const * const _S_facet_categories [ ] ;

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

void
_M_remove_reference ( ) throw ( )
{

;
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & _M_refcount , - 1 ) == 1 )
{
;
try
{ delete this ; }
catch ( ... )
{ }
}
}

_Impl ( const _Impl & , size_t ) ;
_Impl ( const char * , size_t ) ;
_Impl ( size_t ) throw ( ) ;

~ _Impl ( ) throw ( ) ;

_Impl ( const _Impl & ) ;

void
operator = ( const _Impl & ) ;

bool
_M_check_same_name ( )
{
bool __ret = true ;
if ( _M_names [ 1 ] )

for ( size_t __i = 0 ; __ret && __i < _S_categories_size - 1 ; ++ __i )
__ret = __builtin_strcmp ( _M_names [ __i ] , _M_names [ __i + 1 ] ) == 0 ;
return __ret ;
}

void
_M_replace_categories ( const _Impl * , category ) ;

void
_M_replace_category ( const _Impl * , const locale :: id * const * ) ;

void
_M_replace_facet ( const _Impl * , const locale :: id * ) ;

void
_M_install_facet ( const locale :: id * , const facet * ) ;

template < typename _Facet >
void
_M_init_facet ( _Facet * __facet )
{ _M_install_facet ( & _Facet :: id , __facet ) ; }

void
_M_install_cache ( const facet * , size_t ) ;
} ;
#583
template < typename _CharT >
class collate : public locale :: facet
{
public :



typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;


protected :


__c_locale _M_c_locale_collate ;

public :

static locale :: id id ;
#610
explicit
collate ( size_t __refs = 0 )
: facet ( __refs ) , _M_c_locale_collate ( _S_get_c_locale ( ) )
{ }
#624
explicit
collate ( __c_locale __cloc , size_t __refs = 0 )
: facet ( __refs ) , _M_c_locale_collate ( _S_clone_c_locale ( __cloc ) )
{ }
#641
int
compare ( const _CharT * __lo1 , const _CharT * __hi1 ,
const _CharT * __lo2 , const _CharT * __hi2 ) const
{ return this -> do_compare ( __lo1 , __hi1 , __lo2 , __hi2 ) ; }
#660
string_type
transform ( const _CharT * __lo , const _CharT * __hi ) const
{ return this -> do_transform ( __lo , __hi ) ; }
#674
long
hash ( const _CharT * __lo , const _CharT * __hi ) const
{ return this -> do_hash ( __lo , __hi ) ; }


int
_M_compare ( const _CharT * , const _CharT * ) const throw ( ) ;

size_t
_M_transform ( _CharT * , const _CharT * , size_t ) const throw ( ) ;

protected :

virtual
~ collate ( )
{ _S_destroy_c_locale ( _M_c_locale_collate ) ; }
#703
virtual int
do_compare ( const _CharT * __lo1 , const _CharT * __hi1 ,
const _CharT * __lo2 , const _CharT * __hi2 ) const ;
#717
virtual string_type
do_transform ( const _CharT * __lo , const _CharT * __hi ) const ;
#730
virtual long
do_hash ( const _CharT * __lo , const _CharT * __hi ) const ;
} ;

template < typename _CharT >
locale :: id collate < _CharT > :: id ;


template < >
int
collate < char > :: _M_compare ( const char * , const char * ) const throw ( ) ;

template < >
size_t
collate < char > :: _M_transform ( char * , const char * , size_t ) const throw ( ) ;


template < >
int
collate < wchar_t > :: _M_compare ( const wchar_t * , const wchar_t * ) const throw ( ) ;

template < >
size_t
collate < wchar_t > :: _M_transform ( wchar_t * , const wchar_t * , size_t ) const throw ( ) ;



template < typename _CharT >
class collate_byname : public collate < _CharT >
{
public :


typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;


explicit
collate_byname ( const char * __s , size_t __refs = 0 )
: collate < _CharT > ( __refs )
{
if ( __builtin_strcmp ( __s , "C" ) != 0
&& __builtin_strcmp ( __s , "POSIX" ) != 0 )
{
this -> _S_destroy_c_locale ( this -> _M_c_locale_collate ) ;
this -> _S_create_c_locale ( this -> _M_c_locale_collate , __s ) ;
}
}

protected :
virtual
~ collate_byname ( ) { }
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_classes.tcc"
#37
#pragma GCC system_header

namespace std
{


template < typename _Facet >
locale ::
locale ( const locale & __other , _Facet * __f )
{
_M_impl = new _Impl ( * __other . _M_impl , 1 ) ;

try
{ _M_impl -> _M_install_facet ( & _Facet :: id , __f ) ; }
catch ( ... )
{
_M_impl -> _M_remove_reference ( ) ;
throw ;
}
delete [ ] _M_impl -> _M_names [ 0 ] ;
_M_impl -> _M_names [ 0 ] = 0 ;
}

template < typename _Facet >
locale
locale ::
combine ( const locale & __other ) const
{
_Impl * __tmp = new _Impl ( * _M_impl , 1 ) ;
try
{
__tmp -> _M_replace_facet ( __other . _M_impl , & _Facet :: id ) ;
}
catch ( ... )
{
__tmp -> _M_remove_reference ( ) ;
throw ;
}
return locale ( __tmp ) ;
}

template < typename _CharT , typename _Traits , typename _Alloc >
bool
locale ::
operator ( ) ( const basic_string < _CharT , _Traits , _Alloc > & __s1 ,
const basic_string < _CharT , _Traits , _Alloc > & __s2 ) const
{
typedef std :: collate < _CharT > __collate_type ;
const __collate_type & __collate = use_facet < __collate_type > ( * this ) ;
return ( __collate . compare ( __s1 . data ( ) , __s1 . data ( ) + __s1 . length ( ) ,
__s2 . data ( ) , __s2 . data ( ) + __s2 . length ( ) ) < 0 ) ;
}
#102
template < typename _Facet >
bool
has_facet ( const locale & __loc ) throw ( )
{
const size_t __i = _Facet :: id . _M_id ( ) ;
const locale :: facet * * __facets = __loc . _M_impl -> _M_facets ;
return ( __i < __loc . _M_impl -> _M_facets_size



&& static_cast < const _Facet * > ( __facets [ __i ] ) ) ;

}
#130
template < typename _Facet >
const _Facet &
use_facet ( const locale & __loc )
{
const size_t __i = _Facet :: id . _M_id ( ) ;
const locale :: facet * * __facets = __loc . _M_impl -> _M_facets ;
if ( __i >= __loc . _M_impl -> _M_facets_size || ! __facets [ __i ] )
__throw_bad_cast ( ) ;



return static_cast < const _Facet & > ( * __facets [ __i ] ) ;

}



template < typename _CharT >
int
collate < _CharT > :: _M_compare ( const _CharT * , const _CharT * ) const throw ( )
{ return 0 ; }


template < typename _CharT >
size_t
collate < _CharT > :: _M_transform ( _CharT * , const _CharT * , size_t ) const throw ( )
{ return 0 ; }

template < typename _CharT >
int
collate < _CharT > ::
do_compare ( const _CharT * __lo1 , const _CharT * __hi1 ,
const _CharT * __lo2 , const _CharT * __hi2 ) const
{


const string_type __one ( __lo1 , __hi1 ) ;
const string_type __two ( __lo2 , __hi2 ) ;

const _CharT * __p = __one . c_str ( ) ;
const _CharT * __pend = __one . data ( ) + __one . length ( ) ;
const _CharT * __q = __two . c_str ( ) ;
const _CharT * __qend = __two . data ( ) + __two . length ( ) ;




for ( ; ; )
{
const int __res = _M_compare ( __p , __q ) ;
if ( __res )
return __res ;

__p += char_traits < _CharT > :: length ( __p ) ;
__q += char_traits < _CharT > :: length ( __q ) ;
if ( __p == __pend && __q == __qend )
return 0 ;
else if ( __p == __pend )
return - 1 ;
else if ( __q == __qend )
return 1 ;

__p ++ ;
__q ++ ;
}
}

template < typename _CharT >
typename collate < _CharT > :: string_type
collate < _CharT > ::
do_transform ( const _CharT * __lo , const _CharT * __hi ) const
{
string_type __ret ;


const string_type __str ( __lo , __hi ) ;

const _CharT * __p = __str . c_str ( ) ;
const _CharT * __pend = __str . data ( ) + __str . length ( ) ;

size_t __len = ( __hi - __lo ) * 2 ;

_CharT * __c = new _CharT [ __len ] ;

try
{



for ( ; ; )
{

size_t __res = _M_transform ( __c , __p , __len ) ;


if ( __res >= __len )
{
__len = __res + 1 ;
delete [ ] __c , __c = 0 ;
__c = new _CharT [ __len ] ;
__res = _M_transform ( __c , __p , __len ) ;
}

__ret . append ( __c , __res ) ;
__p += char_traits < _CharT > :: length ( __p ) ;
if ( __p == __pend )
break ;

__p ++ ;
__ret . push_back ( _CharT ( ) ) ;
}
}
catch ( ... )
{
delete [ ] __c ;
throw ;
}

delete [ ] __c ;

return __ret ;
}

template < typename _CharT >
long
collate < _CharT > ::
do_hash ( const _CharT * __lo , const _CharT * __hi ) const
{
unsigned long __val = 0 ;
for ( ; __lo < __hi ; ++ __lo )
__val =
* __lo + ( ( __val << 7 )
| ( __val >> ( __gnu_cxx :: __numeric_traits < unsigned long > ::
__digits - 7 ) ) ) ;
return static_cast < long > ( __val ) ;
}




extern template class collate < char > ;
extern template class collate_byname < char > ;

extern template
const collate < char > &
use_facet < collate < char > > ( const locale & ) ;

extern template
bool
has_facet < collate < char > > ( const locale & ) ;


extern template class collate < wchar_t > ;
extern template class collate_byname < wchar_t > ;

extern template
const collate < wchar_t > &
use_facet < collate < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < collate < wchar_t > > ( const locale & ) ;




}
#43 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/ios_base.h"
namespace std
{
#51
enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0 ,
_S_dec = 1L << 1 ,
_S_fixed = 1L << 2 ,
_S_hex = 1L << 3 ,
_S_internal = 1L << 4 ,
_S_left = 1L << 5 ,
_S_oct = 1L << 6 ,
_S_right = 1L << 7 ,
_S_scientific = 1L << 8 ,
_S_showbase = 1L << 9 ,
_S_showpoint = 1L << 10 ,
_S_showpos = 1L << 11 ,
_S_skipws = 1L << 12 ,
_S_unitbuf = 1L << 13 ,
_S_uppercase = 1L << 14 ,
_S_adjustfield = _S_left | _S_right | _S_internal ,
_S_basefield = _S_dec | _S_oct | _S_hex ,
_S_floatfield = _S_scientific | _S_fixed ,
_S_ios_fmtflags_end = 1L << 16
} ;

inline constexpr _Ios_Fmtflags
operator & ( _Ios_Fmtflags __a , _Ios_Fmtflags __b )
{ return _Ios_Fmtflags ( static_cast < int > ( __a ) & static_cast < int > ( __b ) ) ; }

inline constexpr _Ios_Fmtflags
operator | ( _Ios_Fmtflags __a , _Ios_Fmtflags __b )
{ return _Ios_Fmtflags ( static_cast < int > ( __a ) | static_cast < int > ( __b ) ) ; }

inline constexpr _Ios_Fmtflags
operator ^ ( _Ios_Fmtflags __a , _Ios_Fmtflags __b )
{ return _Ios_Fmtflags ( static_cast < int > ( __a ) ^ static_cast < int > ( __b ) ) ; }

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

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

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

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


enum _Ios_Openmode
{
_S_app = 1L << 0 ,
_S_ate = 1L << 1 ,
_S_bin = 1L << 2 ,
_S_in = 1L << 3 ,
_S_out = 1L << 4 ,
_S_trunc = 1L << 5 ,
_S_ios_openmode_end = 1L << 16
} ;

inline constexpr _Ios_Openmode
operator & ( _Ios_Openmode __a , _Ios_Openmode __b )
{ return _Ios_Openmode ( static_cast < int > ( __a ) & static_cast < int > ( __b ) ) ; }

inline constexpr _Ios_Openmode
operator | ( _Ios_Openmode __a , _Ios_Openmode __b )
{ return _Ios_Openmode ( static_cast < int > ( __a ) | static_cast < int > ( __b ) ) ; }

inline constexpr _Ios_Openmode
operator ^ ( _Ios_Openmode __a , _Ios_Openmode __b )
{ return _Ios_Openmode ( static_cast < int > ( __a ) ^ static_cast < int > ( __b ) ) ; }

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

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

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

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


enum _Ios_Iostate
{
_S_goodbit = 0 ,
_S_badbit = 1L << 0 ,
_S_eofbit = 1L << 1 ,
_S_failbit = 1L << 2 ,
_S_ios_iostate_end = 1L << 16
} ;

inline constexpr _Ios_Iostate
operator & ( _Ios_Iostate __a , _Ios_Iostate __b )
{ return _Ios_Iostate ( static_cast < int > ( __a ) & static_cast < int > ( __b ) ) ; }

inline constexpr _Ios_Iostate
operator | ( _Ios_Iostate __a , _Ios_Iostate __b )
{ return _Ios_Iostate ( static_cast < int > ( __a ) | static_cast < int > ( __b ) ) ; }

inline constexpr _Ios_Iostate
operator ^ ( _Ios_Iostate __a , _Ios_Iostate __b )
{ return _Ios_Iostate ( static_cast < int > ( __a ) ^ static_cast < int > ( __b ) ) ; }

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

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

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

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


enum _Ios_Seekdir
{
_S_beg = 0 ,
_S_cur = 1 ,
_S_end = 2 ,
_S_ios_seekdir_end = 1L << 16
} ;
#199
class ios_base
{
public :
#209
class failure : public exception
{
public :


explicit
failure ( const string & __str ) throw ( ) ;



virtual
~ failure ( ) throw ( ) ;

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

private :
string _M_msg ;
} ;
#255
typedef _Ios_Fmtflags fmtflags ;


static const fmtflags boolalpha = _S_boolalpha ;


static const fmtflags dec = _S_dec ;


static const fmtflags fixed = _S_fixed ;


static const fmtflags hex = _S_hex ;




static const fmtflags internal = _S_internal ;



static const fmtflags left = _S_left ;


static const fmtflags oct = _S_oct ;



static const fmtflags right = _S_right ;


static const fmtflags scientific = _S_scientific ;



static const fmtflags showbase = _S_showbase ;



static const fmtflags showpoint = _S_showpoint ;


static const fmtflags showpos = _S_showpos ;


static const fmtflags skipws = _S_skipws ;


static const fmtflags unitbuf = _S_unitbuf ;



static const fmtflags uppercase = _S_uppercase ;


static const fmtflags adjustfield = _S_adjustfield ;


static const fmtflags basefield = _S_basefield ;


static const fmtflags floatfield = _S_floatfield ;
#330
typedef _Ios_Iostate iostate ;



static const iostate badbit = _S_badbit ;


static const iostate eofbit = _S_eofbit ;




static const iostate failbit = _S_failbit ;


static const iostate goodbit = _S_goodbit ;
#361
typedef _Ios_Openmode openmode ;


static const openmode app = _S_app ;


static const openmode ate = _S_ate ;




static const openmode binary = _S_bin ;


static const openmode in = _S_in ;


static const openmode out = _S_out ;


static const openmode trunc = _S_trunc ;
#393
typedef _Ios_Seekdir seekdir ;


static const seekdir beg = _S_beg ;


static const seekdir cur = _S_cur ;


static const seekdir end = _S_end ;


typedef int io_state ;
typedef int open_mode ;
typedef int seek_dir ;

typedef std :: streampos streampos ;
typedef std :: streamoff streamoff ;
#419
enum event
{
erase_event ,
imbue_event ,
copyfmt_event
} ;
#436
typedef void ( * event_callback ) ( event __e , ios_base & __b , int __i ) ;
#448
void
register_callback ( event_callback __fn , int __index ) ;

protected :
streamsize _M_precision ;
streamsize _M_width ;
fmtflags _M_flags ;
iostate _M_exception ;
iostate _M_streambuf_state ;



struct _Callback_list
{

_Callback_list * _M_next ;
ios_base :: event_callback _M_fn ;
int _M_index ;
_Atomic_word _M_refcount ;

_Callback_list ( ios_base :: event_callback __fn , int __index ,
_Callback_list * __cb )
: _M_next ( __cb ) , _M_fn ( __fn ) , _M_index ( __index ) , _M_refcount ( 0 ) { }

void
_M_add_reference ( ) { __gnu_cxx :: __atomic_add_dispatch ( & _M_refcount , 1 ) ; }


int
_M_remove_reference ( )
{

;
int __res = __gnu_cxx :: __exchange_and_add_dispatch ( & _M_refcount , - 1 ) ;
if ( __res == 0 )
{
;
}
return __res ;
}
} ;

_Callback_list * _M_callbacks ;

void
_M_call_callbacks ( event __ev ) throw ( ) ;

void
_M_dispose_callbacks ( void ) throw ( ) ;


struct _Words
{
void * _M_pword ;
long _M_iword ;
_Words ( ) : _M_pword ( 0 ) , _M_iword ( 0 ) { }
} ;


_Words _M_word_zero ;



enum { _S_local_word_size = 8 } ;
_Words _M_local_word [ _S_local_word_size ] ;


int _M_word_size ;
_Words * _M_word ;

_Words &
_M_grow_words ( int __index , bool __iword ) ;


locale _M_ios_locale ;

void
_M_init ( ) throw ( ) ;

public :





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

private :
static _Atomic_word _S_refcount ;
static bool _S_synced_with_stdio ;
} ;
#550
fmtflags
flags ( ) const
{ return _M_flags ; }
#561
fmtflags
flags ( fmtflags __fmtfl )
{
fmtflags __old = _M_flags ;
_M_flags = __fmtfl ;
return __old ;
}
#577
fmtflags
setf ( fmtflags __fmtfl )
{
fmtflags __old = _M_flags ;
_M_flags |= __fmtfl ;
return __old ;
}
#594
fmtflags
setf ( fmtflags __fmtfl , fmtflags __mask )
{
fmtflags __old = _M_flags ;
_M_flags &= ~ __mask ;
_M_flags |= ( __fmtfl & __mask ) ;
return __old ;
}
#609
void
unsetf ( fmtflags __mask )
{ _M_flags &= ~ __mask ; }
#620
streamsize
precision ( ) const
{ return _M_precision ; }
#629
streamsize
precision ( streamsize __prec )
{
streamsize __old = _M_precision ;
_M_precision = __prec ;
return __old ;
}
#643
streamsize
width ( ) const
{ return _M_width ; }
#652
streamsize
width ( streamsize __wide )
{
streamsize __old = _M_width ;
_M_width = __wide ;
return __old ;
}
#671
static bool
sync_with_stdio ( bool __sync = true ) ;
#683
locale
imbue ( const locale & __loc ) throw ( ) ;
#694
locale
getloc ( ) const
{ return _M_ios_locale ; }
#705
const locale &
_M_getloc ( ) const
{ return _M_ios_locale ; }
#724
static int
xalloc ( ) throw ( ) ;
#740
long &
iword ( int __ix )
{
_Words & __word = ( __ix < _M_word_size )
? _M_word [ __ix ] : _M_grow_words ( __ix , true ) ;
return __word . _M_iword ;
}
#761
void * &
pword ( int __ix )
{
_Words & __word = ( __ix < _M_word_size )
? _M_word [ __ix ] : _M_grow_words ( __ix , false ) ;
return __word . _M_pword ;
}
#778
virtual ~ ios_base ( ) ;

protected :
ios_base ( ) throw ( ) ;



private :
ios_base ( const ios_base & ) ;

ios_base &
operator = ( const ios_base & ) ;
} ;



inline ios_base &
boolalpha ( ios_base & __base )
{
__base . setf ( ios_base :: boolalpha ) ;
return __base ;
}


inline ios_base &
noboolalpha ( ios_base & __base )
{
__base . unsetf ( ios_base :: boolalpha ) ;
return __base ;
}


inline ios_base &
showbase ( ios_base & __base )
{
__base . setf ( ios_base :: showbase ) ;
return __base ;
}


inline ios_base &
noshowbase ( ios_base & __base )
{
__base . unsetf ( ios_base :: showbase ) ;
return __base ;
}


inline ios_base &
showpoint ( ios_base & __base )
{
__base . setf ( ios_base :: showpoint ) ;
return __base ;
}


inline ios_base &
noshowpoint ( ios_base & __base )
{
__base . unsetf ( ios_base :: showpoint ) ;
return __base ;
}


inline ios_base &
showpos ( ios_base & __base )
{
__base . setf ( ios_base :: showpos ) ;
return __base ;
}


inline ios_base &
noshowpos ( ios_base & __base )
{
__base . unsetf ( ios_base :: showpos ) ;
return __base ;
}


inline ios_base &
skipws ( ios_base & __base )
{
__base . setf ( ios_base :: skipws ) ;
return __base ;
}


inline ios_base &
noskipws ( ios_base & __base )
{
__base . unsetf ( ios_base :: skipws ) ;
return __base ;
}


inline ios_base &
uppercase ( ios_base & __base )
{
__base . setf ( ios_base :: uppercase ) ;
return __base ;
}


inline ios_base &
nouppercase ( ios_base & __base )
{
__base . unsetf ( ios_base :: uppercase ) ;
return __base ;
}


inline ios_base &
unitbuf ( ios_base & __base )
{
__base . setf ( ios_base :: unitbuf ) ;
return __base ;
}


inline ios_base &
nounitbuf ( ios_base & __base )
{
__base . unsetf ( ios_base :: unitbuf ) ;
return __base ;
}



inline ios_base &
internal ( ios_base & __base )
{
__base . setf ( ios_base :: internal , ios_base :: adjustfield ) ;
return __base ;
}


inline ios_base &
left ( ios_base & __base )
{
__base . setf ( ios_base :: left , ios_base :: adjustfield ) ;
return __base ;
}


inline ios_base &
right ( ios_base & __base )
{
__base . setf ( ios_base :: right , ios_base :: adjustfield ) ;
return __base ;
}



inline ios_base &
dec ( ios_base & __base )
{
__base . setf ( ios_base :: dec , ios_base :: basefield ) ;
return __base ;
}


inline ios_base &
hex ( ios_base & __base )
{
__base . setf ( ios_base :: hex , ios_base :: basefield ) ;
return __base ;
}


inline ios_base &
oct ( ios_base & __base )
{
__base . setf ( ios_base :: oct , ios_base :: basefield ) ;
return __base ;
}



inline ios_base &
fixed ( ios_base & __base )
{
__base . setf ( ios_base :: fixed , ios_base :: floatfield ) ;
return __base ;
}


inline ios_base &
scientific ( ios_base & __base )
{
__base . setf ( ios_base :: scientific , ios_base :: floatfield ) ;
return __base ;
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/streambuf"
#36
#pragma GCC system_header
#45
namespace std
{


template < typename _CharT , typename _Traits >
streamsize
__copy_streambufs_eof ( basic_streambuf < _CharT , _Traits > * ,
basic_streambuf < _CharT , _Traits > * , bool & ) ;
#119
template < typename _CharT , typename _Traits >
class basic_streambuf
{
public :
#129
typedef _CharT char_type ;
typedef _Traits traits_type ;
typedef typename traits_type :: int_type int_type ;
typedef typename traits_type :: pos_type pos_type ;
typedef typename traits_type :: off_type off_type ;




typedef basic_streambuf < char_type , traits_type > __streambuf_type ;


friend class basic_ios < char_type , traits_type > ;
friend class basic_istream < char_type , traits_type > ;
friend class basic_ostream < char_type , traits_type > ;
friend class istreambuf_iterator < char_type , traits_type > ;
friend class ostreambuf_iterator < char_type , traits_type > ;

friend streamsize
__copy_streambufs_eof < > ( basic_streambuf * , basic_streambuf * , bool & ) ;

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

template < typename _CharT2 >
friend typename __gnu_cxx :: __enable_if < __is_char < _CharT2 > :: __value ,
istreambuf_iterator < _CharT2 > > :: __type
find ( istreambuf_iterator < _CharT2 > , istreambuf_iterator < _CharT2 > ,
const _CharT2 & ) ;

template < typename _CharT2 , typename _Traits2 >
friend basic_istream < _CharT2 , _Traits2 > &
operator >> ( basic_istream < _CharT2 , _Traits2 > & , _CharT2 * ) ;

template < typename _CharT2 , typename _Traits2 , typename _Alloc >
friend basic_istream < _CharT2 , _Traits2 > &
operator >> ( basic_istream < _CharT2 , _Traits2 > & ,
basic_string < _CharT2 , _Traits2 , _Alloc > & ) ;

template < typename _CharT2 , typename _Traits2 , typename _Alloc >
friend basic_istream < _CharT2 , _Traits2 > &
getline ( basic_istream < _CharT2 , _Traits2 > & ,
basic_string < _CharT2 , _Traits2 , _Alloc > & , _CharT2 ) ;

protected :
#184
char_type * _M_in_beg ;
char_type * _M_in_cur ;
char_type * _M_in_end ;
char_type * _M_out_beg ;
char_type * _M_out_cur ;
char_type * _M_out_end ;


locale _M_buf_locale ;

public :

virtual
~ basic_streambuf ( )
{ }
#208
locale
pubimbue ( const locale & __loc )
{
locale __tmp ( this -> getloc ( ) ) ;
this -> imbue ( __loc ) ;
_M_buf_locale = __loc ;
return __tmp ;
}
#225
locale
getloc ( ) const
{ return _M_buf_locale ; }
#238
basic_streambuf *
pubsetbuf ( char_type * __s , streamsize __n )
{ return this -> setbuf ( __s , __n ) ; }
#250
pos_type
pubseekoff ( off_type __off , ios_base :: seekdir __way ,
ios_base :: openmode __mode = ios_base :: in | ios_base :: out )
{ return this -> seekoff ( __off , __way , __mode ) ; }
#262
pos_type
pubseekpos ( pos_type __sp ,
ios_base :: openmode __mode = ios_base :: in | ios_base :: out )
{ return this -> seekpos ( __sp , __mode ) ; }




int
pubsync ( ) { return this -> sync ( ) ; }
#283
streamsize
in_avail ( )
{
const streamsize __ret = this -> egptr ( ) - this -> gptr ( ) ;
return __ret ? __ret : this -> showmanyc ( ) ;
}
#297
int_type
snextc ( )
{
int_type __ret = traits_type :: eof ( ) ;
if (
! traits_type :: eq_int_type ( this -> sbumpc ( ) , __ret ) )
__ret = this -> sgetc ( ) ;
return __ret ;
}
#315
int_type
sbumpc ( )
{
int_type __ret ;
if ( this -> gptr ( ) < this -> egptr ( ) )
{
__ret = traits_type :: to_int_type ( * this -> gptr ( ) ) ;
this -> gbump ( 1 ) ;
}
else
__ret = this -> uflow ( ) ;
return __ret ;
}
#337
int_type
sgetc ( )
{
int_type __ret ;
if ( this -> gptr ( ) < this -> egptr ( ) )
__ret = traits_type :: to_int_type ( * this -> gptr ( ) ) ;
else
__ret = this -> underflow ( ) ;
return __ret ;
}
#356
streamsize
sgetn ( char_type * __s , streamsize __n )
{ return this -> xsgetn ( __s , __n ) ; }
#371
int_type
sputbackc ( char_type __c )
{
int_type __ret ;
const bool __testpos = this -> eback ( ) < this -> gptr ( ) ;
if (
! __testpos || ! traits_type :: eq ( __c , this -> gptr ( ) [ - 1 ] ) )
__ret = this -> pbackfail ( traits_type :: to_int_type ( __c ) ) ;
else
{
this -> gbump ( - 1 ) ;
__ret = traits_type :: to_int_type ( * this -> gptr ( ) ) ;
}
return __ret ;
}
#396
int_type
sungetc ( )
{
int_type __ret ;
if ( this -> eback ( ) < this -> gptr ( ) )
{
this -> gbump ( - 1 ) ;
__ret = traits_type :: to_int_type ( * this -> gptr ( ) ) ;
}
else
__ret = this -> pbackfail ( ) ;
return __ret ;
}
#423
int_type
sputc ( char_type __c )
{
int_type __ret ;
if ( this -> pptr ( ) < this -> epptr ( ) )
{
* this -> pptr ( ) = __c ;
this -> pbump ( 1 ) ;
__ret = traits_type :: to_int_type ( __c ) ;
}
else
__ret = this -> overflow ( traits_type :: to_int_type ( __c ) ) ;
return __ret ;
}
#449
streamsize
sputn ( const char_type * __s , streamsize __n )
{ return this -> xsputn ( __s , __n ) ; }

protected :
#463
basic_streambuf ( )
: _M_in_beg ( 0 ) , _M_in_cur ( 0 ) , _M_in_end ( 0 ) ,
_M_out_beg ( 0 ) , _M_out_cur ( 0 ) , _M_out_end ( 0 ) ,
_M_buf_locale ( locale ( ) )
{ }
#481
char_type *
eback ( ) const { return _M_in_beg ; }

char_type *
gptr ( ) const { return _M_in_cur ; }

char_type *
egptr ( ) const { return _M_in_end ; }
#497
void
gbump ( int __n ) { _M_in_cur += __n ; }
#508
void
setg ( char_type * __gbeg , char_type * __gnext , char_type * __gend )
{
_M_in_beg = __gbeg ;
_M_in_cur = __gnext ;
_M_in_end = __gend ;
}
#528
char_type *
pbase ( ) const { return _M_out_beg ; }

char_type *
pptr ( ) const { return _M_out_cur ; }

char_type *
epptr ( ) const { return _M_out_end ; }
#544
void
pbump ( int __n ) { _M_out_cur += __n ; }
#554
void
setp ( char_type * __pbeg , char_type * __pend )
{
_M_out_beg = _M_out_cur = __pbeg ;
_M_out_end = __pend ;
}
#575
virtual void
imbue ( const locale & __loc )
{ }
#590
virtual basic_streambuf < char_type , _Traits > *
setbuf ( char_type * , streamsize )
{ return this ; }
#601
virtual pos_type
seekoff ( off_type , ios_base :: seekdir ,
ios_base :: openmode = ios_base :: in | ios_base :: out )
{ return pos_type ( off_type ( - 1 ) ) ; }
#613
virtual pos_type
seekpos ( pos_type ,
ios_base :: openmode = ios_base :: in | ios_base :: out )
{ return pos_type ( off_type ( - 1 ) ) ; }
#626
virtual int
sync ( ) { return 0 ; }
#648
virtual streamsize
showmanyc ( ) { return 0 ; }
#664
virtual streamsize
xsgetn ( char_type * __s , streamsize __n ) ;
#686
virtual int_type
underflow ( )
{ return traits_type :: eof ( ) ; }
#699
virtual int_type
uflow ( )
{
int_type __ret = traits_type :: eof ( ) ;
const bool __testeof = traits_type :: eq_int_type ( this -> underflow ( ) ,
__ret ) ;
if ( ! __testeof )
{
__ret = traits_type :: to_int_type ( * this -> gptr ( ) ) ;
this -> gbump ( 1 ) ;
}
return __ret ;
}
#723
virtual int_type
pbackfail ( int_type __c = traits_type :: eof ( ) )
{ return traits_type :: eof ( ) ; }
#741
virtual streamsize
xsputn ( const char_type * __s , streamsize __n ) ;
#767
virtual int_type
overflow ( int_type __c = traits_type :: eof ( ) )
{ return traits_type :: eof ( ) ; }



public :
#782
void
stossc ( )
{
if ( this -> gptr ( ) < this -> egptr ( ) )
this -> gbump ( 1 ) ;
else
this -> uflow ( ) ;
}



void
__safe_gbump ( streamsize __n ) { _M_in_cur += __n ; }

void
__safe_pbump ( streamsize __n ) { _M_out_cur += __n ; }

private :


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

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


template < >
streamsize
__copy_streambufs_eof ( basic_streambuf < char > * __sbin ,
basic_streambuf < char > * __sbout , bool & __ineof ) ;

template < >
streamsize
__copy_streambufs_eof ( basic_streambuf < wchar_t > * __sbin ,
basic_streambuf < wchar_t > * __sbout , bool & __ineof ) ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/streambuf.tcc"
#37
#pragma GCC system_header

namespace std
{


template < typename _CharT , typename _Traits >
streamsize
basic_streambuf < _CharT , _Traits > ::
xsgetn ( char_type * __s , streamsize __n )
{
streamsize __ret = 0 ;
while ( __ret < __n )
{
const streamsize __buf_len = this -> egptr ( ) - this -> gptr ( ) ;
if ( __buf_len )
{
const streamsize __remaining = __n - __ret ;
const streamsize __len = std :: min ( __buf_len , __remaining ) ;
traits_type :: copy ( __s , this -> gptr ( ) , __len ) ;
__ret += __len ;
__s += __len ;
this -> __safe_gbump ( __len ) ;
}

if ( __ret < __n )
{
const int_type __c = this -> uflow ( ) ;
if ( ! traits_type :: eq_int_type ( __c , traits_type :: eof ( ) ) )
{
traits_type :: assign ( * __s ++ , traits_type :: to_char_type ( __c ) ) ;
++ __ret ;
}
else
break ;
}
}
return __ret ;
}

template < typename _CharT , typename _Traits >
streamsize
basic_streambuf < _CharT , _Traits > ::
xsputn ( const char_type * __s , streamsize __n )
{
streamsize __ret = 0 ;
while ( __ret < __n )
{
const streamsize __buf_len = this -> epptr ( ) - this -> pptr ( ) ;
if ( __buf_len )
{
const streamsize __remaining = __n - __ret ;
const streamsize __len = std :: min ( __buf_len , __remaining ) ;
traits_type :: copy ( this -> pptr ( ) , __s , __len ) ;
__ret += __len ;
__s += __len ;
this -> __safe_pbump ( __len ) ;
}

if ( __ret < __n )
{
int_type __c = this -> overflow ( traits_type :: to_int_type ( * __s ) ) ;
if ( ! traits_type :: eq_int_type ( __c , traits_type :: eof ( ) ) )
{
++ __ret ;
++ __s ;
}
else
break ;
}
}
return __ret ;
}




template < typename _CharT , typename _Traits >
streamsize
__copy_streambufs_eof ( basic_streambuf < _CharT , _Traits > * __sbin ,
basic_streambuf < _CharT , _Traits > * __sbout ,
bool & __ineof )
{
streamsize __ret = 0 ;
__ineof = true ;
typename _Traits :: int_type __c = __sbin -> sgetc ( ) ;
while ( ! _Traits :: eq_int_type ( __c , _Traits :: eof ( ) ) )
{
__c = __sbout -> sputc ( _Traits :: to_char_type ( __c ) ) ;
if ( _Traits :: eq_int_type ( __c , _Traits :: eof ( ) ) )
{
__ineof = false ;
break ;
}
++ __ret ;
__c = __sbin -> snextc ( ) ;
}
return __ret ;
}

template < typename _CharT , typename _Traits >
inline streamsize
__copy_streambufs ( basic_streambuf < _CharT , _Traits > * __sbin ,
basic_streambuf < _CharT , _Traits > * __sbout )
{
bool __ineof ;
return __copy_streambufs_eof ( __sbin , __sbout , __ineof ) ;
}




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


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




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_ios.h"
#33
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets.h"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/ctype_base.h"
#33
namespace std
{



struct ctype_base
{

typedef int * __to_type ;



typedef unsigned int mask ;
static const mask upper = 0x00000001 ;
static const mask lower = 0x00000002 ;
static const mask alpha = 0x00004000 ;
static const mask digit = 0x00000004 ;
static const mask xdigit = 0x00000080 ;
static const mask space = 0x00000008 ;
static const mask print = 0x00008000 ;
static const mask graph = 0x00004000 | 0x00000004 | 0x00000010 ;
static const mask cntrl = 0x00000020 ;
static const mask punct = 0x00000010 ;
static const mask alnum = 0x00004000 | 0x00000004 ;
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/streambuf_iterator.h"
#33
#pragma GCC system_header
#38
namespace std
{
#49
template < typename _CharT , typename _Traits >
class istreambuf_iterator
: public iterator < input_iterator_tag , _CharT , typename _Traits :: off_type ,
_CharT * ,


_CharT >



{
public :



typedef _CharT char_type ;
typedef _Traits traits_type ;
typedef typename _Traits :: int_type int_type ;
typedef basic_streambuf < _CharT , _Traits > streambuf_type ;
typedef basic_istream < _CharT , _Traits > istream_type ;


template < typename _CharT2 >
friend typename __gnu_cxx :: __enable_if < __is_char < _CharT2 > :: __value ,
ostreambuf_iterator < _CharT2 > > :: __type
copy ( istreambuf_iterator < _CharT2 > , istreambuf_iterator < _CharT2 > ,
ostreambuf_iterator < _CharT2 > ) ;

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

template < typename _CharT2 >
friend typename __gnu_cxx :: __enable_if < __is_char < _CharT2 > :: __value ,
istreambuf_iterator < _CharT2 > > :: __type
find ( istreambuf_iterator < _CharT2 > , istreambuf_iterator < _CharT2 > ,
const _CharT2 & ) ;

private :
#97
mutable streambuf_type * _M_sbuf ;
mutable int_type _M_c ;

public :

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


istreambuf_iterator ( const istreambuf_iterator & ) noexcept = default ;

~ istreambuf_iterator ( ) = default ;



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


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




char_type
operator * ( ) const
{
#132
return traits_type :: to_char_type ( _M_get ( ) ) ;
}


istreambuf_iterator &
operator ++ ( )
{


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


istreambuf_iterator
operator ++ ( int )
{


;

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





bool
equal ( const istreambuf_iterator & __b ) const
{ return _M_at_eof ( ) == __b . _M_at_eof ( ) ; }

private :
int_type
_M_get ( ) const
{
const int_type __eof = traits_type :: eof ( ) ;
int_type __ret = __eof ;
if ( _M_sbuf )
{
if ( ! traits_type :: eq_int_type ( _M_c , __eof ) )
__ret = _M_c ;
else if ( ! traits_type :: eq_int_type ( ( __ret = _M_sbuf -> sgetc ( ) ) ,
__eof ) )
_M_c = __ret ;
else
_M_sbuf = 0 ;
}
return __ret ;
}

bool
_M_at_eof ( ) const
{
const int_type __eof = traits_type :: eof ( ) ;
return traits_type :: eq_int_type ( _M_get ( ) , __eof ) ;
}
} ;

template < typename _CharT , typename _Traits >
inline bool
operator == ( const istreambuf_iterator < _CharT , _Traits > & __a ,
const istreambuf_iterator < _CharT , _Traits > & __b )
{ return __a . equal ( __b ) ; }

template < typename _CharT , typename _Traits >
inline bool
operator != ( const istreambuf_iterator < _CharT , _Traits > & __a ,
const istreambuf_iterator < _CharT , _Traits > & __b )
{ return ! __a . equal ( __b ) ; }


template < typename _CharT , typename _Traits >
class ostreambuf_iterator
: public iterator < output_iterator_tag , void , void , void , void >
{
public :



typedef _CharT char_type ;
typedef _Traits traits_type ;
typedef basic_streambuf < _CharT , _Traits > streambuf_type ;
typedef basic_ostream < _CharT , _Traits > ostream_type ;


template < typename _CharT2 >
friend typename __gnu_cxx :: __enable_if < __is_char < _CharT2 > :: __value ,
ostreambuf_iterator < _CharT2 > > :: __type
copy ( istreambuf_iterator < _CharT2 > , istreambuf_iterator < _CharT2 > ,
ostreambuf_iterator < _CharT2 > ) ;

private :
streambuf_type * _M_sbuf ;
bool _M_failed ;

public :

ostreambuf_iterator ( ostream_type & __s ) noexcept
: _M_sbuf ( __s . rdbuf ( ) ) , _M_failed ( ! _M_sbuf ) { }


ostreambuf_iterator ( streambuf_type * __s ) noexcept
: _M_sbuf ( __s ) , _M_failed ( ! _M_sbuf ) { }


ostreambuf_iterator &
operator = ( _CharT __c )
{
if ( ! _M_failed &&
_Traits :: eq_int_type ( _M_sbuf -> sputc ( __c ) , _Traits :: eof ( ) ) )
_M_failed = true ;
return * this ;
}


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


ostreambuf_iterator &
operator ++ ( int )
{ return * this ; }


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


bool
failed ( ) const noexcept
{ return _M_failed ; }

ostreambuf_iterator &
_M_put ( const _CharT * __ws , streamsize __len )
{
if ( ! _M_failed
&&
this -> _M_sbuf -> sputn ( __ws , __len ) != __len )
_M_failed = true ;
return * this ;
}
} ;


template < typename _CharT >
typename __gnu_cxx :: __enable_if < __is_char < _CharT > :: __value ,
ostreambuf_iterator < _CharT > > :: __type
copy ( istreambuf_iterator < _CharT > __first ,
istreambuf_iterator < _CharT > __last ,
ostreambuf_iterator < _CharT > __result )
{
if ( __first . _M_sbuf && ! __last . _M_sbuf && ! __result . _M_failed )
{
bool __ineof ;
__copy_streambufs_eof ( __first . _M_sbuf , __result . _M_sbuf , __ineof ) ;
if ( ! __ineof )
__result . _M_failed = true ;
}
return __result ;
}

template < bool _IsMove , typename _CharT >
typename __gnu_cxx :: __enable_if < __is_char < _CharT > :: __value ,
ostreambuf_iterator < _CharT > > :: __type
__copy_move_a2 ( _CharT * __first , _CharT * __last ,
ostreambuf_iterator < _CharT > __result )
{
const streamsize __num = __last - __first ;
if ( __num > 0 )
__result . _M_put ( __first , __num ) ;
return __result ;
}

template < bool _IsMove , typename _CharT >
typename __gnu_cxx :: __enable_if < __is_char < _CharT > :: __value ,
ostreambuf_iterator < _CharT > > :: __type
__copy_move_a2 ( const _CharT * __first , const _CharT * __last ,
ostreambuf_iterator < _CharT > __result )
{
const streamsize __num = __last - __first ;
if ( __num > 0 )
__result . _M_put ( __first , __num ) ;
return __result ;
}

template < bool _IsMove , typename _CharT >
typename __gnu_cxx :: __enable_if < __is_char < _CharT > :: __value ,
_CharT * > :: __type
__copy_move_a2 ( istreambuf_iterator < _CharT > __first ,
istreambuf_iterator < _CharT > __last , _CharT * __result )
{
typedef istreambuf_iterator < _CharT > __is_iterator_type ;
typedef typename __is_iterator_type :: traits_type traits_type ;
typedef typename __is_iterator_type :: streambuf_type streambuf_type ;
typedef typename traits_type :: int_type int_type ;

if ( __first . _M_sbuf && ! __last . _M_sbuf )
{
streambuf_type * __sb = __first . _M_sbuf ;
int_type __c = __sb -> sgetc ( ) ;
while ( ! traits_type :: eq_int_type ( __c , traits_type :: eof ( ) ) )
{
const streamsize __n = __sb -> egptr ( ) - __sb -> gptr ( ) ;
if ( __n > 1 )
{
traits_type :: copy ( __result , __sb -> gptr ( ) , __n ) ;
__sb -> __safe_gbump ( __n ) ;
__result += __n ;
__c = __sb -> underflow ( ) ;
}
else
{
* __result ++ = traits_type :: to_char_type ( __c ) ;
__c = __sb -> snextc ( ) ;
}
}
}
return __result ;
}

template < typename _CharT >
typename __gnu_cxx :: __enable_if < __is_char < _CharT > :: __value ,
istreambuf_iterator < _CharT > > :: __type
find ( istreambuf_iterator < _CharT > __first ,
istreambuf_iterator < _CharT > __last , const _CharT & __val )
{
typedef istreambuf_iterator < _CharT > __is_iterator_type ;
typedef typename __is_iterator_type :: traits_type traits_type ;
typedef typename __is_iterator_type :: streambuf_type streambuf_type ;
typedef typename traits_type :: int_type int_type ;

if ( __first . _M_sbuf && ! __last . _M_sbuf )
{
const int_type __ival = traits_type :: to_int_type ( __val ) ;
streambuf_type * __sb = __first . _M_sbuf ;
int_type __c = __sb -> sgetc ( ) ;
while ( ! traits_type :: eq_int_type ( __c , traits_type :: eof ( ) )
&& ! traits_type :: eq_int_type ( __c , __ival ) )
{
streamsize __n = __sb -> egptr ( ) - __sb -> gptr ( ) ;
if ( __n > 1 )
{
const _CharT * __p = traits_type :: find ( __sb -> gptr ( ) ,
__n , __val ) ;
if ( __p )
__n = __p - __sb -> gptr ( ) ;
__sb -> __safe_gbump ( __n ) ;
__c = __sb -> sgetc ( ) ;
}
else
__c = __sb -> snextc ( ) ;
}

if ( ! traits_type :: eq_int_type ( __c , traits_type :: eof ( ) ) )
__first . _M_c = __c ;
else
__first . _M_sbuf = 0 ;
}
return __first ;
}




}
#50 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets.h"
namespace std
{
#64
template < typename _Tp >
void
__convert_to_v ( const char * , _Tp & , ios_base :: iostate & ,
const __c_locale & ) throw ( ) ;


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

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

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



template < typename _CharT , typename _Traits >
struct __pad
{
static void
_S_pad ( ios_base & __io , _CharT __fill , _CharT * __news ,
const _CharT * __olds , streamsize __newlen , streamsize __oldlen ) ;
} ;
#100
template < typename _CharT >
_CharT *
__add_grouping ( _CharT * __s , _CharT __sep ,
const char * __gbeg , size_t __gsize ,
const _CharT * __first , const _CharT * __last ) ;




template < typename _CharT >
inline
ostreambuf_iterator < _CharT >
__write ( ostreambuf_iterator < _CharT > __s , const _CharT * __ws , int __len )
{
__s . _M_put ( __ws , __len ) ;
return __s ;
}


template < typename _CharT , typename _OutIter >
inline
_OutIter
__write ( _OutIter __s , const _CharT * __ws , int __len )
{
for ( int __j = 0 ; __j < __len ; __j ++ , ++ __s )
* __s = __ws [ __j ] ;
return __s ;
}
#142
template < typename _CharT >
class __ctype_abstract_base : public locale :: facet , public ctype_base
{
public :


typedef _CharT char_type ;
#161
bool
is ( mask __m , char_type __c ) const
{ return this -> do_is ( __m , __c ) ; }
#178
const char_type *
is ( const char_type * __lo , const char_type * __hi , mask * __vec ) const
{ return this -> do_is ( __lo , __hi , __vec ) ; }
#194
const char_type *
scan_is ( mask __m , const char_type * __lo , const char_type * __hi ) const
{ return this -> do_scan_is ( __m , __lo , __hi ) ; }
#210
const char_type *
scan_not ( mask __m , const char_type * __lo , const char_type * __hi ) const
{ return this -> do_scan_not ( __m , __lo , __hi ) ; }
#224
char_type
toupper ( char_type __c ) const
{ return this -> do_toupper ( __c ) ; }
#239
const char_type *
toupper ( char_type * __lo , const char_type * __hi ) const
{ return this -> do_toupper ( __lo , __hi ) ; }
#253
char_type
tolower ( char_type __c ) const
{ return this -> do_tolower ( __c ) ; }
#268
const char_type *
tolower ( char_type * __lo , const char_type * __hi ) const
{ return this -> do_tolower ( __lo , __hi ) ; }
#285
char_type
widen ( char __c ) const
{ return this -> do_widen ( __c ) ; }
#304
const char *
widen ( const char * __lo , const char * __hi , char_type * __to ) const
{ return this -> do_widen ( __lo , __hi , __to ) ; }
#323
char
narrow ( char_type __c , char __dfault ) const
{ return this -> do_narrow ( __c , __dfault ) ; }
#345
const char_type *
narrow ( const char_type * __lo , const char_type * __hi ,
char __dfault , char * __to ) const
{ return this -> do_narrow ( __lo , __hi , __dfault , __to ) ; }

protected :
explicit
__ctype_abstract_base ( size_t __refs = 0 ) : facet ( __refs ) { }

virtual
~ __ctype_abstract_base ( ) { }
#370
virtual bool
do_is ( mask __m , char_type __c ) const = 0 ;
#389
virtual const char_type *
do_is ( const char_type * __lo , const char_type * __hi ,
mask * __vec ) const = 0 ;
#408
virtual const char_type *
do_scan_is ( mask __m , const char_type * __lo ,
const char_type * __hi ) const = 0 ;
#427
virtual const char_type *
do_scan_not ( mask __m , const char_type * __lo ,
const char_type * __hi ) const = 0 ;
#445
virtual char_type
do_toupper ( char_type __c ) const = 0 ;
#462
virtual const char_type *
do_toupper ( char_type * __lo , const char_type * __hi ) const = 0 ;
#478
virtual char_type
do_tolower ( char_type __c ) const = 0 ;
#495
virtual const char_type *
do_tolower ( char_type * __lo , const char_type * __hi ) const = 0 ;
#514
virtual char_type
do_widen ( char __c ) const = 0 ;
#535
virtual const char *
do_widen ( const char * __lo , const char * __hi , char_type * __to ) const = 0 ;
#556
virtual char
do_narrow ( char_type __c , char __dfault ) const = 0 ;
#581
virtual const char_type *
do_narrow ( const char_type * __lo , const char_type * __hi ,
char __dfault , char * __to ) const = 0 ;
} ;
#604
template < typename _CharT >
class ctype : public __ctype_abstract_base < _CharT >
{
public :

typedef _CharT char_type ;
typedef typename __ctype_abstract_base < _CharT > :: mask mask ;


static locale :: id id ;

explicit
ctype ( size_t __refs = 0 ) : __ctype_abstract_base < _CharT > ( __refs ) { }

protected :
virtual
~ ctype ( ) ;

virtual bool
do_is ( mask __m , char_type __c ) const ;

virtual const char_type *
do_is ( const char_type * __lo , const char_type * __hi , mask * __vec ) const ;

virtual const char_type *
do_scan_is ( mask __m , const char_type * __lo , const char_type * __hi ) const ;

virtual const char_type *
do_scan_not ( mask __m , const char_type * __lo ,
const char_type * __hi ) const ;

virtual char_type
do_toupper ( char_type __c ) const ;

virtual const char_type *
do_toupper ( char_type * __lo , const char_type * __hi ) const ;

virtual char_type
do_tolower ( char_type __c ) const ;

virtual const char_type *
do_tolower ( char_type * __lo , const char_type * __hi ) const ;

virtual char_type
do_widen ( char __c ) const ;

virtual const char *
do_widen ( const char * __lo , const char * __hi , char_type * __dest ) const ;

virtual char
do_narrow ( char_type , char __dfault ) const ;

virtual const char_type *
do_narrow ( const char_type * __lo , const char_type * __hi ,
char __dfault , char * __to ) const ;
} ;

template < typename _CharT >
locale :: id ctype < _CharT > :: id ;
#673
template < >
class ctype < char > : public locale :: facet , public ctype_base
{
public :


typedef char char_type ;

protected :

__c_locale _M_c_locale_ctype ;
bool _M_del ;
__to_type _M_toupper ;
__to_type _M_tolower ;
const mask * _M_table ;
mutable char _M_widen_ok ;
mutable char _M_widen [ 1 + static_cast < unsigned char > ( - 1 ) ] ;
mutable char _M_narrow [ 1 + static_cast < unsigned char > ( - 1 ) ] ;
mutable char _M_narrow_ok ;


public :

static locale :: id id ;

static const size_t table_size = 1 + static_cast < unsigned char > ( - 1 ) ;
#710
explicit
ctype ( const mask * __table = 0 , bool __del = false , size_t __refs = 0 ) ;
#723
explicit
ctype ( __c_locale __cloc , const mask * __table = 0 , bool __del = false ,
size_t __refs = 0 ) ;
#736
inline bool
is ( mask __m , char __c ) const ;
#751
inline const char *
is ( const char * __lo , const char * __hi , mask * __vec ) const ;
#765
inline const char *
scan_is ( mask __m , const char * __lo , const char * __hi ) const ;
#779
inline const char *
scan_not ( mask __m , const char * __lo , const char * __hi ) const ;
#794
char_type
toupper ( char_type __c ) const
{ return this -> do_toupper ( __c ) ; }
#811
const char_type *
toupper ( char_type * __lo , const char_type * __hi ) const
{ return this -> do_toupper ( __lo , __hi ) ; }
#827
char_type
tolower ( char_type __c ) const
{ return this -> do_tolower ( __c ) ; }
#844
const char_type *
tolower ( char_type * __lo , const char_type * __hi ) const
{ return this -> do_tolower ( __lo , __hi ) ; }
#864
char_type
widen ( char __c ) const
{
if ( _M_widen_ok )
return _M_widen [ static_cast < unsigned char > ( __c ) ] ;
this -> _M_widen_init ( ) ;
return this -> do_widen ( __c ) ;
}
#891
const char *
widen ( const char * __lo , const char * __hi , char_type * __to ) const
{
if ( _M_widen_ok == 1 )
{
__builtin_memcpy ( __to , __lo , __hi - __lo ) ;
return __hi ;
}
if ( ! _M_widen_ok )
_M_widen_init ( ) ;
return this -> do_widen ( __lo , __hi , __to ) ;
}
#922
char
narrow ( char_type __c , char __dfault ) const
{
if ( _M_narrow [ static_cast < unsigned char > ( __c ) ] )
return _M_narrow [ static_cast < unsigned char > ( __c ) ] ;
const char __t = do_narrow ( __c , __dfault ) ;
if ( __t != __dfault )
_M_narrow [ static_cast < unsigned char > ( __c ) ] = __t ;
return __t ;
}
#955
const char_type *
narrow ( const char_type * __lo , const char_type * __hi ,
char __dfault , char * __to ) const
{
if ( _M_narrow_ok == 1 )
{
__builtin_memcpy ( __to , __lo , __hi - __lo ) ;
return __hi ;
}
if ( ! _M_narrow_ok )
_M_narrow_init ( ) ;
return this -> do_narrow ( __lo , __hi , __dfault , __to ) ;
}





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


static const mask *
classic_table ( ) throw ( ) ;
protected :
#988
virtual
~ ctype ( ) ;
#1004
virtual char_type
do_toupper ( char_type __c ) const ;
#1021
virtual const char_type *
do_toupper ( char_type * __lo , const char_type * __hi ) const ;
#1037
virtual char_type
do_tolower ( char_type __c ) const ;
#1054
virtual const char_type *
do_tolower ( char_type * __lo , const char_type * __hi ) const ;
#1074
virtual char_type
do_widen ( char __c ) const
{ return __c ; }
#1097
virtual const char *
do_widen ( const char * __lo , const char * __hi , char_type * __to ) const
{
__builtin_memcpy ( __to , __lo , __hi - __lo ) ;
return __hi ;
}
#1123
virtual char
do_narrow ( char_type __c , char __dfault ) const
{ return __c ; }
#1149
virtual const char_type *
do_narrow ( const char_type * __lo , const char_type * __hi ,
char __dfault , char * __to ) const
{
__builtin_memcpy ( __to , __lo , __hi - __lo ) ;
return __hi ;
}

private :
void _M_narrow_init ( ) const ;
void _M_widen_init ( ) const ;
} ;
#1174
template < >
class ctype < wchar_t > : public __ctype_abstract_base < wchar_t >
{
public :


typedef wchar_t char_type ;
typedef wctype_t __wmask_type ;

protected :
__c_locale _M_c_locale_ctype ;


bool _M_narrow_ok ;
char _M_narrow [ 128 ] ;
wint_t _M_widen [ 1 + static_cast < unsigned char > ( - 1 ) ] ;


mask _M_bit [ 16 ] ;
__wmask_type _M_wmask [ 16 ] ;

public :


static locale :: id id ;
#1207
explicit
ctype ( size_t __refs = 0 ) ;
#1218
explicit
ctype ( __c_locale __cloc , size_t __refs = 0 ) ;

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


virtual
~ ctype ( ) ;
#1242
virtual bool
do_is ( mask __m , char_type __c ) const ;
#1261
virtual const char_type *
do_is ( const char_type * __lo , const char_type * __hi , mask * __vec ) const ;
#1279
virtual const char_type *
do_scan_is ( mask __m , const char_type * __lo , const char_type * __hi ) const ;
#1297
virtual const char_type *
do_scan_not ( mask __m , const char_type * __lo ,
const char_type * __hi ) const ;
#1314
virtual char_type
do_toupper ( char_type __c ) const ;
#1331
virtual const char_type *
do_toupper ( char_type * __lo , const char_type * __hi ) const ;
#1347
virtual char_type
do_tolower ( char_type __c ) const ;
#1364
virtual const char_type *
do_tolower ( char_type * __lo , const char_type * __hi ) const ;
#1384
virtual char_type
do_widen ( char __c ) const ;
#1406
virtual const char *
do_widen ( const char * __lo , const char * __hi , char_type * __to ) const ;
#1429
virtual char
do_narrow ( char_type __c , char __dfault ) const ;
#1455
virtual const char_type *
do_narrow ( const char_type * __lo , const char_type * __hi ,
char __dfault , char * __to ) const ;


void
_M_initialize_ctype ( ) throw ( ) ;
} ;



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

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

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


template < >
class ctype_byname < char > : public ctype < char >
{
public :
explicit
ctype_byname ( const char * __s , size_t __refs = 0 ) ;

protected :
virtual
~ ctype_byname ( ) ;
} ;


template < >
class ctype_byname < wchar_t > : public ctype < wchar_t >
{
public :
explicit
ctype_byname ( const char * __s , size_t __refs = 0 ) ;

protected :
virtual
~ ctype_byname ( ) ;
} ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/ctype_inline.h"
#37
namespace std
{


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


}
#1513 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets.h"
namespace std
{



class __num_base
{
public :


enum
{
_S_ominus ,
_S_oplus ,
_S_ox ,
_S_oX ,
_S_odigits ,
_S_odigits_end = _S_odigits + 16 ,
_S_oudigits = _S_odigits_end ,
_S_oudigits_end = _S_oudigits + 16 ,
_S_oe = _S_odigits + 14 ,
_S_oE = _S_oudigits + 14 ,
_S_oend = _S_oudigits_end
} ;
#1543
static const char * _S_atoms_out ;



static const char * _S_atoms_in ;

enum
{
_S_iminus ,
_S_iplus ,
_S_ix ,
_S_iX ,
_S_izero ,
_S_ie = _S_izero + 14 ,
_S_iE = _S_izero + 20 ,
_S_iend = 26
} ;



static void
_S_format_float ( const ios_base & __io , char * __fptr , char __mod ) throw ( ) ;
} ;

template < typename _CharT >
struct __numpunct_cache : public locale :: facet
{
const char * _M_grouping ;
size_t _M_grouping_size ;
bool _M_use_grouping ;
const _CharT * _M_truename ;
size_t _M_truename_size ;
const _CharT * _M_falsename ;
size_t _M_falsename_size ;
_CharT _M_decimal_point ;
_CharT _M_thousands_sep ;





_CharT _M_atoms_out [ __num_base :: _S_oend ] ;





_CharT _M_atoms_in [ __num_base :: _S_iend ] ;

bool _M_allocated ;

__numpunct_cache ( size_t __refs = 0 )
: facet ( __refs ) , _M_grouping ( 0 ) , _M_grouping_size ( 0 ) ,
_M_use_grouping ( false ) ,
_M_truename ( 0 ) , _M_truename_size ( 0 ) , _M_falsename ( 0 ) ,
_M_falsename_size ( 0 ) , _M_decimal_point ( _CharT ( ) ) ,
_M_thousands_sep ( _CharT ( ) ) , _M_allocated ( false )
{ }

~ __numpunct_cache ( ) ;

void
_M_cache ( const locale & __loc ) ;

private :
__numpunct_cache &
operator = ( const __numpunct_cache & ) ;

explicit
__numpunct_cache ( const __numpunct_cache & ) ;
} ;

template < typename _CharT >
__numpunct_cache < _CharT > :: ~ __numpunct_cache ( )
{
if ( _M_allocated )
{
delete [ ] _M_grouping ;
delete [ ] _M_truename ;
delete [ ] _M_falsename ;
}
}
#1640
template < typename _CharT >
class numpunct : public locale :: facet
{
public :



typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;

typedef __numpunct_cache < _CharT > __cache_type ;

protected :
__cache_type * _M_data ;

public :

static locale :: id id ;
#1664
explicit
numpunct ( size_t __refs = 0 )
: facet ( __refs ) , _M_data ( 0 )
{ _M_initialize_numpunct ( ) ; }
#1678
explicit
numpunct ( __cache_type * __cache , size_t __refs = 0 )
: facet ( __refs ) , _M_data ( __cache )
{ _M_initialize_numpunct ( ) ; }
#1692
explicit
numpunct ( __c_locale __cloc , size_t __refs = 0 )
: facet ( __refs ) , _M_data ( 0 )
{ _M_initialize_numpunct ( __cloc ) ; }
#1706
char_type
decimal_point ( ) const
{ return this -> do_decimal_point ( ) ; }
#1719
char_type
thousands_sep ( ) const
{ return this -> do_thousands_sep ( ) ; }
#1750
string
grouping ( ) const
{ return this -> do_grouping ( ) ; }
#1763
string_type
truename ( ) const
{ return this -> do_truename ( ) ; }
#1776
string_type
falsename ( ) const
{ return this -> do_falsename ( ) ; }

protected :

virtual
~ numpunct ( ) ;
#1793
virtual char_type
do_decimal_point ( ) const
{ return _M_data -> _M_decimal_point ; }
#1805
virtual char_type
do_thousands_sep ( ) const
{ return _M_data -> _M_thousands_sep ; }
#1818
virtual string
do_grouping ( ) const
{ return _M_data -> _M_grouping ; }
#1831
virtual string_type
do_truename ( ) const
{ return _M_data -> _M_truename ; }
#1844
virtual string_type
do_falsename ( ) const
{ return _M_data -> _M_falsename ; }


void
_M_initialize_numpunct ( __c_locale __cloc = 0 ) ;
} ;

template < typename _CharT >
locale :: id numpunct < _CharT > :: id ;

template < >
numpunct < char > :: ~ numpunct ( ) ;

template < >
void
numpunct < char > :: _M_initialize_numpunct ( __c_locale __cloc ) ;


template < >
numpunct < wchar_t > :: ~ numpunct ( ) ;

template < >
void
numpunct < wchar_t > :: _M_initialize_numpunct ( __c_locale __cloc ) ;



template < typename _CharT >
class numpunct_byname : public numpunct < _CharT >
{
public :
typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;

explicit
numpunct_byname ( const char * __s , size_t __refs = 0 )
: numpunct < _CharT > ( __refs )
{
if ( __builtin_strcmp ( __s , "C" ) != 0
&& __builtin_strcmp ( __s , "POSIX" ) != 0 )
{
__c_locale __tmp ;
this -> _S_create_c_locale ( __tmp , __s ) ;
this -> _M_initialize_numpunct ( __tmp ) ;
this -> _S_destroy_c_locale ( __tmp ) ;
}
}

protected :
virtual
~ numpunct_byname ( ) { }
} ;
#1914
template < typename _CharT , typename _InIter >
class num_get : public locale :: facet
{
public :



typedef _CharT char_type ;
typedef _InIter iter_type ;



static locale :: id id ;
#1935
explicit
num_get ( size_t __refs = 0 ) : facet ( __refs ) { }
#1961
iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , bool & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }
#1998
iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , long & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }

iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned short & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }

iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned int & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }

iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned long & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }


iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , long long & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }

iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned long long & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }
#2058
iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , float & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }

iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , double & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }

iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , long double & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }
#2101
iter_type
get ( iter_type __in , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , void * & __v ) const
{ return this -> do_get ( __in , __end , __io , __err , __v ) ; }

protected :

virtual ~ num_get ( ) { }

iter_type
_M_extract_float ( iter_type , iter_type , ios_base & , ios_base :: iostate & ,
string & ) const ;

template < typename _ValueT >
iter_type
_M_extract_int ( iter_type , iter_type , ios_base & , ios_base :: iostate & ,
_ValueT & ) const ;

template < typename _CharT2 >
typename __gnu_cxx :: __enable_if < __is_char < _CharT2 > :: __value , int > :: __type
_M_find ( const _CharT2 * , size_t __len , _CharT2 __c ) const
{
int __ret = - 1 ;
if ( __len <= 10 )
{
if ( __c >= _CharT2 ( '0' ) && __c < _CharT2 ( _CharT2 ( '0' ) + __len ) )
__ret = __c - _CharT2 ( '0' ) ;
}
else
{
if ( __c >= _CharT2 ( '0' ) && __c <= _CharT2 ( '9' ) )
__ret = __c - _CharT2 ( '0' ) ;
else if ( __c >= _CharT2 ( 'a' ) && __c <= _CharT2 ( 'f' ) )
__ret = 10 + ( __c - _CharT2 ( 'a' ) ) ;
else if ( __c >= _CharT2 ( 'A' ) && __c <= _CharT2 ( 'F' ) )
__ret = 10 + ( __c - _CharT2 ( 'A' ) ) ;
}
return __ret ;
}

template < typename _CharT2 >
typename __gnu_cxx :: __enable_if < ! __is_char < _CharT2 > :: __value ,
int > :: __type
_M_find ( const _CharT2 * __zero , size_t __len , _CharT2 __c ) const
{
int __ret = - 1 ;
const char_type * __q = char_traits < _CharT2 > :: find ( __zero , __len , __c ) ;
if ( __q )
{
__ret = __q - __zero ;
if ( __ret > 15 )
__ret -= 6 ;
}
return __ret ;
}
#2172
virtual iter_type
do_get ( iter_type , iter_type , ios_base & , ios_base :: iostate & , bool & ) const ;

virtual iter_type
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , long & __v ) const
{ return _M_extract_int ( __beg , __end , __io , __err , __v ) ; }

virtual iter_type
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned short & __v ) const
{ return _M_extract_int ( __beg , __end , __io , __err , __v ) ; }

virtual iter_type
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned int & __v ) const
{ return _M_extract_int ( __beg , __end , __io , __err , __v ) ; }

virtual iter_type
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned long & __v ) const
{ return _M_extract_int ( __beg , __end , __io , __err , __v ) ; }


virtual iter_type
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , long long & __v ) const
{ return _M_extract_int ( __beg , __end , __io , __err , __v ) ; }

virtual iter_type
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , unsigned long long & __v ) const
{ return _M_extract_int ( __beg , __end , __io , __err , __v ) ; }


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

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


virtual iter_type
do_get ( iter_type , iter_type , ios_base & , ios_base :: iostate & , void * & ) const ;
#2235
} ;

template < typename _CharT , typename _InIter >
locale :: id num_get < _CharT , _InIter > :: id ;
#2253
template < typename _CharT , typename _OutIter >
class num_put : public locale :: facet
{
public :



typedef _CharT char_type ;
typedef _OutIter iter_type ;



static locale :: id id ;
#2274
explicit
num_put ( size_t __refs = 0 ) : facet ( __refs ) { }
#2292
iter_type
put ( iter_type __s , ios_base & __io , char_type __fill , bool __v ) const
{ return this -> do_put ( __s , __io , __fill , __v ) ; }
#2334
iter_type
put ( iter_type __s , ios_base & __io , char_type __fill , long __v ) const
{ return this -> do_put ( __s , __io , __fill , __v ) ; }

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


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

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

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

protected :
template < typename _ValueT >
iter_type
_M_insert_float ( iter_type , ios_base & __io , char_type __fill ,
char __mod , _ValueT __v ) const ;

void
_M_group_float ( const char * __grouping , size_t __grouping_size ,
char_type __sep , const char_type * __p , char_type * __new ,
char_type * __cs , int & __len ) const ;

template < typename _ValueT >
iter_type
_M_insert_int ( iter_type , ios_base & __io , char_type __fill ,
_ValueT __v ) const ;

void
_M_group_int ( const char * __grouping , size_t __grouping_size ,
char_type __sep , ios_base & __io , char_type * __new ,
char_type * __cs , int & __len ) const ;

void
_M_pad ( char_type __fill , streamsize __w , ios_base & __io ,
char_type * __new , const char_type * __cs , int & __len ) const ;


virtual
~ num_put ( ) { } ;
#2470
virtual iter_type
do_put ( iter_type __s , ios_base & __io , char_type __fill , bool __v ) const ;

virtual iter_type
do_put ( iter_type __s , ios_base & __io , char_type __fill , long __v ) const
{ return _M_insert_int ( __s , __io , __fill , __v ) ; }

virtual iter_type
do_put ( iter_type __s , ios_base & __io , char_type __fill ,
unsigned long __v ) const
{ return _M_insert_int ( __s , __io , __fill , __v ) ; }


virtual iter_type
do_put ( iter_type __s , ios_base & __io , char_type __fill ,
long long __v ) const
{ return _M_insert_int ( __s , __io , __fill , __v ) ; }

virtual iter_type
do_put ( iter_type __s , ios_base & __io , char_type __fill ,
unsigned long long __v ) const
{ return _M_insert_int ( __s , __io , __fill , __v ) ; }


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


virtual iter_type
do_put ( iter_type , ios_base & , char_type , const void * ) const ;
#2515
} ;

template < typename _CharT , typename _OutIter >
locale :: id num_put < _CharT , _OutIter > :: id ;
#2528
template < typename _CharT >
inline bool
isspace ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: space , __c ) ; }


template < typename _CharT >
inline bool
isprint ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: print , __c ) ; }


template < typename _CharT >
inline bool
iscntrl ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: cntrl , __c ) ; }


template < typename _CharT >
inline bool
isupper ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: upper , __c ) ; }


template < typename _CharT >
inline bool
islower ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: lower , __c ) ; }


template < typename _CharT >
inline bool
isalpha ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: alpha , __c ) ; }


template < typename _CharT >
inline bool
isdigit ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: digit , __c ) ; }


template < typename _CharT >
inline bool
ispunct ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: punct , __c ) ; }


template < typename _CharT >
inline bool
isxdigit ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: xdigit , __c ) ; }


template < typename _CharT >
inline bool
isalnum ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: alnum , __c ) ; }


template < typename _CharT >
inline bool
isgraph ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . is ( ctype_base :: graph , __c ) ; }


template < typename _CharT >
inline _CharT
toupper ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . toupper ( __c ) ; }


template < typename _CharT >
inline _CharT
tolower ( _CharT __c , const locale & __loc )
{ return use_facet < ctype < _CharT > > ( __loc ) . tolower ( __c ) ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets.tcc"
#33
#pragma GCC system_header

namespace std
{




template < typename _Facet >
struct __use_cache
{
const _Facet *
operator ( ) ( const locale & __loc ) const ;
} ;


template < typename _CharT >
struct __use_cache < __numpunct_cache < _CharT > >
{
const __numpunct_cache < _CharT > *
operator ( ) ( const locale & __loc ) const
{
const size_t __i = numpunct < _CharT > :: id . _M_id ( ) ;
const locale :: facet * * __caches = __loc . _M_impl -> _M_caches ;
if ( ! __caches [ __i ] )
{
__numpunct_cache < _CharT > * __tmp = 0 ;
try
{
__tmp = new __numpunct_cache < _CharT > ;
__tmp -> _M_cache ( __loc ) ;
}
catch ( ... )
{
delete __tmp ;
throw ;
}
__loc . _M_impl -> _M_install_cache ( __tmp , __i ) ;
}
return static_cast < const __numpunct_cache < _CharT > * > ( __caches [ __i ] ) ;
}
} ;

template < typename _CharT >
void
__numpunct_cache < _CharT > :: _M_cache ( const locale & __loc )
{
_M_allocated = true ;

const numpunct < _CharT > & __np = use_facet < numpunct < _CharT > > ( __loc ) ;

char * __grouping = 0 ;
_CharT * __truename = 0 ;
_CharT * __falsename = 0 ;
try
{
_M_grouping_size = __np . grouping ( ) . size ( ) ;
__grouping = new char [ _M_grouping_size ] ;
__np . grouping ( ) . copy ( __grouping , _M_grouping_size ) ;
_M_grouping = __grouping ;
_M_use_grouping = ( _M_grouping_size
&& static_cast < signed char > ( _M_grouping [ 0 ] ) > 0
&& ( _M_grouping [ 0 ]
!= __gnu_cxx :: __numeric_traits < char > :: __max ) ) ;

_M_truename_size = __np . truename ( ) . size ( ) ;
__truename = new _CharT [ _M_truename_size ] ;
__np . truename ( ) . copy ( __truename , _M_truename_size ) ;
_M_truename = __truename ;

_M_falsename_size = __np . falsename ( ) . size ( ) ;
__falsename = new _CharT [ _M_falsename_size ] ;
__np . falsename ( ) . copy ( __falsename , _M_falsename_size ) ;
_M_falsename = __falsename ;

_M_decimal_point = __np . decimal_point ( ) ;
_M_thousands_sep = __np . thousands_sep ( ) ;

const ctype < _CharT > & __ct = use_facet < ctype < _CharT > > ( __loc ) ;
__ct . widen ( __num_base :: _S_atoms_out ,
__num_base :: _S_atoms_out
+ __num_base :: _S_oend , _M_atoms_out ) ;
__ct . widen ( __num_base :: _S_atoms_in ,
__num_base :: _S_atoms_in
+ __num_base :: _S_iend , _M_atoms_in ) ;
}
catch ( ... )
{
delete [ ] __grouping ;
delete [ ] __truename ;
delete [ ] __falsename ;
throw ;
}
}
#136
__attribute__ ( ( __pure__ ) ) bool
__verify_grouping ( const char * __grouping , size_t __grouping_size ,
const string & __grouping_tmp ) throw ( ) ;



template < typename _CharT , typename _InIter >
_InIter
num_get < _CharT , _InIter > ::
_M_extract_float ( _InIter __beg , _InIter __end , ios_base & __io ,
ios_base :: iostate & __err , string & __xtrc ) const
{
typedef char_traits < _CharT > __traits_type ;
typedef __numpunct_cache < _CharT > __cache_type ;
__use_cache < __cache_type > __uc ;
const locale & __loc = __io . _M_getloc ( ) ;
const __cache_type * __lc = __uc ( __loc ) ;
const _CharT * __lit = __lc -> _M_atoms_in ;
char_type __c = char_type ( ) ;


bool __testeof = __beg == __end ;


if ( ! __testeof )
{
__c = * __beg ;
const bool __plus = __c == __lit [ __num_base :: _S_iplus ] ;
if ( ( __plus || __c == __lit [ __num_base :: _S_iminus ] )
&& ! ( __lc -> _M_use_grouping && __c == __lc -> _M_thousands_sep )
&& ! ( __c == __lc -> _M_decimal_point ) )
{
__xtrc += __plus ? '+' : '-' ;
if ( ++ __beg != __end )
__c = * __beg ;
else
__testeof = true ;
}
}


bool __found_mantissa = false ;
int __sep_pos = 0 ;
while ( ! __testeof )
{
if ( ( __lc -> _M_use_grouping && __c == __lc -> _M_thousands_sep )
|| __c == __lc -> _M_decimal_point )
break ;
else if ( __c == __lit [ __num_base :: _S_izero ] )
{
if ( ! __found_mantissa )
{
__xtrc += '0' ;
__found_mantissa = true ;
}
++ __sep_pos ;

if ( ++ __beg != __end )
__c = * __beg ;
else
__testeof = true ;
}
else
break ;
}


bool __found_dec = false ;
bool __found_sci = false ;
string __found_grouping ;
if ( __lc -> _M_use_grouping )
__found_grouping . reserve ( 32 ) ;
const char_type * __lit_zero = __lit + __num_base :: _S_izero ;

if ( ! __lc -> _M_allocated )

while ( ! __testeof )
{
const int __digit = _M_find ( __lit_zero , 10 , __c ) ;
if ( __digit != - 1 )
{
__xtrc += '0' + __digit ;
__found_mantissa = true ;
}
else if ( __c == __lc -> _M_decimal_point
&& ! __found_dec && ! __found_sci )
{
__xtrc += '.' ;
__found_dec = true ;
}
else if ( ( __c == __lit [ __num_base :: _S_ie ]
|| __c == __lit [ __num_base :: _S_iE ] )
&& ! __found_sci && __found_mantissa )
{

__xtrc += 'e' ;
__found_sci = true ;


if ( ++ __beg != __end )
{
__c = * __beg ;
const bool __plus = __c == __lit [ __num_base :: _S_iplus ] ;
if ( __plus || __c == __lit [ __num_base :: _S_iminus ] )
__xtrc += __plus ? '+' : '-' ;
else
continue ;
}
else
{
__testeof = true ;
break ;
}
}
else
break ;

if ( ++ __beg != __end )
__c = * __beg ;
else
__testeof = true ;
}
else
while ( ! __testeof )
{


if ( __lc -> _M_use_grouping && __c == __lc -> _M_thousands_sep )
{
if ( ! __found_dec && ! __found_sci )
{


if ( __sep_pos )
{
__found_grouping += static_cast < char > ( __sep_pos ) ;
__sep_pos = 0 ;
}
else
{


__xtrc . clear ( ) ;
break ;
}
}
else
break ;
}
else if ( __c == __lc -> _M_decimal_point )
{
if ( ! __found_dec && ! __found_sci )
{



if ( __found_grouping . size ( ) )
__found_grouping += static_cast < char > ( __sep_pos ) ;
__xtrc += '.' ;
__found_dec = true ;
}
else
break ;
}
else
{
const char_type * __q =
__traits_type :: find ( __lit_zero , 10 , __c ) ;
if ( __q )
{
__xtrc += '0' + ( __q - __lit_zero ) ;
__found_mantissa = true ;
++ __sep_pos ;
}
else if ( ( __c == __lit [ __num_base :: _S_ie ]
|| __c == __lit [ __num_base :: _S_iE ] )
&& ! __found_sci && __found_mantissa )
{

if ( __found_grouping . size ( ) && ! __found_dec )
__found_grouping += static_cast < char > ( __sep_pos ) ;
__xtrc += 'e' ;
__found_sci = true ;


if ( ++ __beg != __end )
{
__c = * __beg ;
const bool __plus = __c == __lit [ __num_base :: _S_iplus ] ;
if ( ( __plus || __c == __lit [ __num_base :: _S_iminus ] )
&& ! ( __lc -> _M_use_grouping
&& __c == __lc -> _M_thousands_sep )
&& ! ( __c == __lc -> _M_decimal_point ) )
__xtrc += __plus ? '+' : '-' ;
else
continue ;
}
else
{
__testeof = true ;
break ;
}
}
else
break ;
}

if ( ++ __beg != __end )
__c = * __beg ;
else
__testeof = true ;
}



if ( __found_grouping . size ( ) )
{

if ( ! __found_dec && ! __found_sci )
__found_grouping += static_cast < char > ( __sep_pos ) ;

if ( ! std :: __verify_grouping ( __lc -> _M_grouping ,
__lc -> _M_grouping_size ,
__found_grouping ) )
__err = ios_base :: failbit ;
}

return __beg ;
}

template < typename _CharT , typename _InIter >
template < typename _ValueT >
_InIter
num_get < _CharT , _InIter > ::
_M_extract_int ( _InIter __beg , _InIter __end , ios_base & __io ,
ios_base :: iostate & __err , _ValueT & __v ) const
{
typedef char_traits < _CharT > __traits_type ;
using __gnu_cxx :: __add_unsigned ;
typedef typename __add_unsigned < _ValueT > :: __type __unsigned_type ;
typedef __numpunct_cache < _CharT > __cache_type ;
__use_cache < __cache_type > __uc ;
const locale & __loc = __io . _M_getloc ( ) ;
const __cache_type * __lc = __uc ( __loc ) ;
const _CharT * __lit = __lc -> _M_atoms_in ;
char_type __c = char_type ( ) ;


const ios_base :: fmtflags __basefield = __io . flags ( )
& ios_base :: basefield ;
const bool __oct = __basefield == ios_base :: oct ;
int __base = __oct ? 8 : ( __basefield == ios_base :: hex ? 16 : 10 ) ;


bool __testeof = __beg == __end ;


bool __negative = false ;
if ( ! __testeof )
{
__c = * __beg ;
__negative = __c == __lit [ __num_base :: _S_iminus ] ;
if ( ( __negative || __c == __lit [ __num_base :: _S_iplus ] )
&& ! ( __lc -> _M_use_grouping && __c == __lc -> _M_thousands_sep )
&& ! ( __c == __lc -> _M_decimal_point ) )
{
if ( ++ __beg != __end )
__c = * __beg ;
else
__testeof = true ;
}
}



bool __found_zero = false ;
int __sep_pos = 0 ;
while ( ! __testeof )
{
if ( ( __lc -> _M_use_grouping && __c == __lc -> _M_thousands_sep )
|| __c == __lc -> _M_decimal_point )
break ;
else if ( __c == __lit [ __num_base :: _S_izero ]
&& ( ! __found_zero || __base == 10 ) )
{
__found_zero = true ;
++ __sep_pos ;
if ( __basefield == 0 )
__base = 8 ;
if ( __base == 8 )
__sep_pos = 0 ;
}
else if ( __found_zero
&& ( __c == __lit [ __num_base :: _S_ix ]
|| __c == __lit [ __num_base :: _S_iX ] ) )
{
if ( __basefield == 0 )
__base = 16 ;
if ( __base == 16 )
{
__found_zero = false ;
__sep_pos = 0 ;
}
else
break ;
}
else
break ;

if ( ++ __beg != __end )
{
__c = * __beg ;
if ( ! __found_zero )
break ;
}
else
__testeof = true ;
}



const size_t __len = ( __base == 16 ? __num_base :: _S_iend
- __num_base :: _S_izero : __base ) ;


string __found_grouping ;
if ( __lc -> _M_use_grouping )
__found_grouping . reserve ( 32 ) ;
bool __testfail = false ;
bool __testoverflow = false ;
const __unsigned_type __max =
( __negative && __gnu_cxx :: __numeric_traits < _ValueT > :: __is_signed )
? - __gnu_cxx :: __numeric_traits < _ValueT > :: __min
: __gnu_cxx :: __numeric_traits < _ValueT > :: __max ;
const __unsigned_type __smax = __max / __base ;
__unsigned_type __result = 0 ;
int __digit = 0 ;
const char_type * __lit_zero = __lit + __num_base :: _S_izero ;

if ( ! __lc -> _M_allocated )

while ( ! __testeof )
{
__digit = _M_find ( __lit_zero , __len , __c ) ;
if ( __digit == - 1 )
break ;

if ( __result > __smax )
__testoverflow = true ;
else
{
__result *= __base ;
__testoverflow |= __result > __max - __digit ;
__result += __digit ;
++ __sep_pos ;
}

if ( ++ __beg != __end )
__c = * __beg ;
else
__testeof = true ;
}
else
while ( ! __testeof )
{


if ( __lc -> _M_use_grouping && __c == __lc -> _M_thousands_sep )
{


if ( __sep_pos )
{
__found_grouping += static_cast < char > ( __sep_pos ) ;
__sep_pos = 0 ;
}
else
{
__testfail = true ;
break ;
}
}
else if ( __c == __lc -> _M_decimal_point )
break ;
else
{
const char_type * __q =
__traits_type :: find ( __lit_zero , __len , __c ) ;
if ( ! __q )
break ;

__digit = __q - __lit_zero ;
if ( __digit > 15 )
__digit -= 6 ;
if ( __result > __smax )
__testoverflow = true ;
else
{
__result *= __base ;
__testoverflow |= __result > __max - __digit ;
__result += __digit ;
++ __sep_pos ;
}
}

if ( ++ __beg != __end )
__c = * __beg ;
else
__testeof = true ;
}



if ( __found_grouping . size ( ) )
{

__found_grouping += static_cast < char > ( __sep_pos ) ;

if ( ! std :: __verify_grouping ( __lc -> _M_grouping ,
__lc -> _M_grouping_size ,
__found_grouping ) )
__err = ios_base :: failbit ;
}



if ( ( ! __sep_pos && ! __found_zero && ! __found_grouping . size ( ) )
|| __testfail )
{
__v = 0 ;
__err = ios_base :: failbit ;
}
else if ( __testoverflow )
{
if ( __negative
&& __gnu_cxx :: __numeric_traits < _ValueT > :: __is_signed )
__v = __gnu_cxx :: __numeric_traits < _ValueT > :: __min ;
else
__v = __gnu_cxx :: __numeric_traits < _ValueT > :: __max ;
__err = ios_base :: failbit ;
}
else
__v = __negative ? - __result : __result ;

if ( __testeof )
__err |= ios_base :: eofbit ;
return __beg ;
}



template < typename _CharT , typename _InIter >
_InIter
num_get < _CharT , _InIter > ::
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , bool & __v ) const
{
if ( ! ( __io . flags ( ) & ios_base :: boolalpha ) )
{



long __l = - 1 ;
__beg = _M_extract_int ( __beg , __end , __io , __err , __l ) ;
if ( __l == 0 || __l == 1 )
__v = bool ( __l ) ;
else
{


__v = true ;
__err = ios_base :: failbit ;
if ( __beg == __end )
__err |= ios_base :: eofbit ;
}
}
else
{

typedef __numpunct_cache < _CharT > __cache_type ;
__use_cache < __cache_type > __uc ;
const locale & __loc = __io . _M_getloc ( ) ;
const __cache_type * __lc = __uc ( __loc ) ;

bool __testf = true ;
bool __testt = true ;
bool __donef = __lc -> _M_falsename_size == 0 ;
bool __donet = __lc -> _M_truename_size == 0 ;
bool __testeof = false ;
size_t __n = 0 ;
while ( ! __donef || ! __donet )
{
if ( __beg == __end )
{
__testeof = true ;
break ;
}

const char_type __c = * __beg ;

if ( ! __donef )
__testf = __c == __lc -> _M_falsename [ __n ] ;

if ( ! __testf && __donet )
break ;

if ( ! __donet )
__testt = __c == __lc -> _M_truename [ __n ] ;

if ( ! __testt && __donef )
break ;

if ( ! __testt && ! __testf )
break ;

++ __n ;
++ __beg ;

__donef = ! __testf || __n >= __lc -> _M_falsename_size ;
__donet = ! __testt || __n >= __lc -> _M_truename_size ;
}
if ( __testf && __n == __lc -> _M_falsename_size && __n )
{
__v = false ;
if ( __testt && __n == __lc -> _M_truename_size )
__err = ios_base :: failbit ;
else
__err = __testeof ? ios_base :: eofbit : ios_base :: goodbit ;
}
else if ( __testt && __n == __lc -> _M_truename_size && __n )
{
__v = true ;
__err = __testeof ? ios_base :: eofbit : ios_base :: goodbit ;
}
else
{


__v = false ;
__err = ios_base :: failbit ;
if ( __testeof )
__err |= ios_base :: eofbit ;
}
}
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
num_get < _CharT , _InIter > ::
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , float & __v ) const
{
string __xtrc ;
__xtrc . reserve ( 32 ) ;
__beg = _M_extract_float ( __beg , __end , __io , __err , __xtrc ) ;
std :: __convert_to_v ( __xtrc . c_str ( ) , __v , __err , _S_get_c_locale ( ) ) ;
if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
num_get < _CharT , _InIter > ::
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , double & __v ) const
{
string __xtrc ;
__xtrc . reserve ( 32 ) ;
__beg = _M_extract_float ( __beg , __end , __io , __err , __xtrc ) ;
std :: __convert_to_v ( __xtrc . c_str ( ) , __v , __err , _S_get_c_locale ( ) ) ;
if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}
#730
template < typename _CharT , typename _InIter >
_InIter
num_get < _CharT , _InIter > ::
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , long double & __v ) const
{
string __xtrc ;
__xtrc . reserve ( 32 ) ;
__beg = _M_extract_float ( __beg , __end , __io , __err , __xtrc ) ;
std :: __convert_to_v ( __xtrc . c_str ( ) , __v , __err , _S_get_c_locale ( ) ) ;
if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
num_get < _CharT , _InIter > ::
do_get ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , void * & __v ) const
{

typedef ios_base :: fmtflags fmtflags ;
const fmtflags __fmt = __io . flags ( ) ;
__io . flags ( ( __fmt & ~ ios_base :: basefield ) | ios_base :: hex ) ;

typedef __gnu_cxx :: __conditional_type < ( sizeof ( void * )
<= sizeof ( unsigned long ) ) ,
unsigned long , unsigned long long > :: __type _UIntPtrType ;

_UIntPtrType __ul ;
__beg = _M_extract_int ( __beg , __end , __io , __err , __ul ) ;


__io . flags ( __fmt ) ;

__v = reinterpret_cast < void * > ( __ul ) ;
return __beg ;
}



template < typename _CharT , typename _OutIter >
void
num_put < _CharT , _OutIter > ::
_M_pad ( _CharT __fill , streamsize __w , ios_base & __io ,
_CharT * __new , const _CharT * __cs , int & __len ) const
{


__pad < _CharT , char_traits < _CharT > > :: _S_pad ( __io , __fill , __new ,
__cs , __w , __len ) ;
__len = static_cast < int > ( __w ) ;
}



template < typename _CharT , typename _ValueT >
int
__int_to_char ( _CharT * __bufend , _ValueT __v , const _CharT * __lit ,
ios_base :: fmtflags __flags , bool __dec )
{
_CharT * __buf = __bufend ;
if ( __dec )
{

do
{
* -- __buf = __lit [ ( __v % 10 ) + __num_base :: _S_odigits ] ;
__v /= 10 ;
}
while ( __v != 0 ) ;
}
else if ( ( __flags & ios_base :: basefield ) == ios_base :: oct )
{

do
{
* -- __buf = __lit [ ( __v & 0x7 ) + __num_base :: _S_odigits ] ;
__v >>= 3 ;
}
while ( __v != 0 ) ;
}
else
{

const bool __uppercase = __flags & ios_base :: uppercase ;
const int __case_offset = __uppercase ? __num_base :: _S_oudigits
: __num_base :: _S_odigits ;
do
{
* -- __buf = __lit [ ( __v & 0xf ) + __case_offset ] ;
__v >>= 4 ;
}
while ( __v != 0 ) ;
}
return __bufend - __buf ;
}



template < typename _CharT , typename _OutIter >
void
num_put < _CharT , _OutIter > ::
_M_group_int ( const char * __grouping , size_t __grouping_size , _CharT __sep ,
ios_base & , _CharT * __new , _CharT * __cs , int & __len ) const
{
_CharT * __p = std :: __add_grouping ( __new , __sep , __grouping ,
__grouping_size , __cs , __cs + __len ) ;
__len = __p - __new ;
}

template < typename _CharT , typename _OutIter >
template < typename _ValueT >
_OutIter
num_put < _CharT , _OutIter > ::
_M_insert_int ( _OutIter __s , ios_base & __io , _CharT __fill ,
_ValueT __v ) const
{
using __gnu_cxx :: __add_unsigned ;
typedef typename __add_unsigned < _ValueT > :: __type __unsigned_type ;
typedef __numpunct_cache < _CharT > __cache_type ;
__use_cache < __cache_type > __uc ;
const locale & __loc = __io . _M_getloc ( ) ;
const __cache_type * __lc = __uc ( __loc ) ;
const _CharT * __lit = __lc -> _M_atoms_out ;
const ios_base :: fmtflags __flags = __io . flags ( ) ;


const int __ilen = 5 * sizeof ( _ValueT ) ;
_CharT * __cs = static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* __ilen ) ) ;



const ios_base :: fmtflags __basefield = __flags & ios_base :: basefield ;
const bool __dec = ( __basefield != ios_base :: oct
&& __basefield != ios_base :: hex ) ;
const __unsigned_type __u = ( ( __v > 0 || ! __dec )
? __unsigned_type ( __v )
: - __unsigned_type ( __v ) ) ;
int __len = __int_to_char ( __cs + __ilen , __u , __lit , __flags , __dec ) ;
__cs += __ilen - __len ;


if ( __lc -> _M_use_grouping )
{


_CharT * __cs2 = static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* ( __len + 1 )
* 2 ) ) ;
_M_group_int ( __lc -> _M_grouping , __lc -> _M_grouping_size ,
__lc -> _M_thousands_sep , __io , __cs2 + 2 , __cs , __len ) ;
__cs = __cs2 + 2 ;
}


if ( __dec )
{

if ( __v >= 0 )
{
if ( bool ( __flags & ios_base :: showpos )
&& __gnu_cxx :: __numeric_traits < _ValueT > :: __is_signed )
* -- __cs = __lit [ __num_base :: _S_oplus ] , ++ __len ;
}
else
* -- __cs = __lit [ __num_base :: _S_ominus ] , ++ __len ;
}
else if ( bool ( __flags & ios_base :: showbase ) && __v )
{
if ( __basefield == ios_base :: oct )
* -- __cs = __lit [ __num_base :: _S_odigits ] , ++ __len ;
else
{

const bool __uppercase = __flags & ios_base :: uppercase ;
* -- __cs = __lit [ __num_base :: _S_ox + __uppercase ] ;

* -- __cs = __lit [ __num_base :: _S_odigits ] ;
__len += 2 ;
}
}


const streamsize __w = __io . width ( ) ;
if ( __w > static_cast < streamsize > ( __len ) )
{
_CharT * __cs3 = static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* __w ) ) ;
_M_pad ( __fill , __w , __io , __cs3 , __cs , __len ) ;
__cs = __cs3 ;
}
__io . width ( 0 ) ;



return std :: __write ( __s , __cs , __len ) ;
}

template < typename _CharT , typename _OutIter >
void
num_put < _CharT , _OutIter > ::
_M_group_float ( const char * __grouping , size_t __grouping_size ,
_CharT __sep , const _CharT * __p , _CharT * __new ,
_CharT * __cs , int & __len ) const
{



const int __declen = __p ? __p - __cs : __len ;
_CharT * __p2 = std :: __add_grouping ( __new , __sep , __grouping ,
__grouping_size ,
__cs , __cs + __declen ) ;


int __newlen = __p2 - __new ;
if ( __p )
{
char_traits < _CharT > :: copy ( __p2 , __p , __len - __declen ) ;
__newlen += __len - __declen ;
}
__len = __newlen ;
}
#966
template < typename _CharT , typename _OutIter >
template < typename _ValueT >
_OutIter
num_put < _CharT , _OutIter > ::
_M_insert_float ( _OutIter __s , ios_base & __io , _CharT __fill , char __mod ,
_ValueT __v ) const
{
typedef __numpunct_cache < _CharT > __cache_type ;
__use_cache < __cache_type > __uc ;
const locale & __loc = __io . _M_getloc ( ) ;
const __cache_type * __lc = __uc ( __loc ) ;


const streamsize __prec = __io . precision ( ) < 0 ? 6 : __io . precision ( ) ;

const int __max_digits =
__gnu_cxx :: __numeric_traits < _ValueT > :: __digits10 ;


int __len ;

char __fbuf [ 16 ] ;
__num_base :: _S_format_float ( __io , __fbuf , __mod ) ;




int __cs_size = __max_digits * 3 ;
char * __cs = static_cast < char * > ( __builtin_alloca ( __cs_size ) ) ;
__len = std :: __convert_from_v ( _S_get_c_locale ( ) , __cs , __cs_size ,
__fbuf , __prec , __v ) ;


if ( __len >= __cs_size )
{
__cs_size = __len + 1 ;
__cs = static_cast < char * > ( __builtin_alloca ( __cs_size ) ) ;
__len = std :: __convert_from_v ( _S_get_c_locale ( ) , __cs , __cs_size ,
__fbuf , __prec , __v ) ;
}
#1027
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;

_CharT * __ws = static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* __len ) ) ;
__ctype . widen ( __cs , __cs + __len , __ws ) ;


_CharT * __wp = 0 ;
const char * __p = char_traits < char > :: find ( __cs , __len , '.' ) ;
if ( __p )
{
__wp = __ws + ( __p - __cs ) ;
* __wp = __lc -> _M_decimal_point ;
}




if ( __lc -> _M_use_grouping
&& ( __wp || __len < 3 || ( __cs [ 1 ] <= '9' && __cs [ 2 ] <= '9'
&& __cs [ 1 ] >= '0' && __cs [ 2 ] >= '0' ) ) )
{


_CharT * __ws2 = static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* __len * 2 ) ) ;

streamsize __off = 0 ;
if ( __cs [ 0 ] == '-' || __cs [ 0 ] == '+' )
{
__off = 1 ;
__ws2 [ 0 ] = __ws [ 0 ] ;
__len -= 1 ;
}

_M_group_float ( __lc -> _M_grouping , __lc -> _M_grouping_size ,
__lc -> _M_thousands_sep , __wp , __ws2 + __off ,
__ws + __off , __len ) ;
__len += __off ;

__ws = __ws2 ;
}


const streamsize __w = __io . width ( ) ;
if ( __w > static_cast < streamsize > ( __len ) )
{
_CharT * __ws3 = static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* __w ) ) ;
_M_pad ( __fill , __w , __io , __ws3 , __ws , __len ) ;
__ws = __ws3 ;
}
__io . width ( 0 ) ;



return std :: __write ( __s , __ws , __len ) ;
}

template < typename _CharT , typename _OutIter >
_OutIter
num_put < _CharT , _OutIter > ::
do_put ( iter_type __s , ios_base & __io , char_type __fill , bool __v ) const
{
const ios_base :: fmtflags __flags = __io . flags ( ) ;
if ( ( __flags & ios_base :: boolalpha ) == 0 )
{
const long __l = __v ;
__s = _M_insert_int ( __s , __io , __fill , __l ) ;
}
else
{
typedef __numpunct_cache < _CharT > __cache_type ;
__use_cache < __cache_type > __uc ;
const locale & __loc = __io . _M_getloc ( ) ;
const __cache_type * __lc = __uc ( __loc ) ;

const _CharT * __name = __v ? __lc -> _M_truename
: __lc -> _M_falsename ;
int __len = __v ? __lc -> _M_truename_size
: __lc -> _M_falsename_size ;

const streamsize __w = __io . width ( ) ;
if ( __w > static_cast < streamsize > ( __len ) )
{
const streamsize __plen = __w - __len ;
_CharT * __ps
= static_cast < _CharT * > ( __builtin_alloca ( sizeof ( _CharT )
* __plen ) ) ;

char_traits < _CharT > :: assign ( __ps , __plen , __fill ) ;
__io . width ( 0 ) ;

if ( ( __flags & ios_base :: adjustfield ) == ios_base :: left )
{
__s = std :: __write ( __s , __name , __len ) ;
__s = std :: __write ( __s , __ps , __plen ) ;
}
else
{
__s = std :: __write ( __s , __ps , __plen ) ;
__s = std :: __write ( __s , __name , __len ) ;
}
return __s ;
}
__io . width ( 0 ) ;
__s = std :: __write ( __s , __name , __len ) ;
}
return __s ;
}

template < typename _CharT , typename _OutIter >
_OutIter
num_put < _CharT , _OutIter > ::
do_put ( iter_type __s , ios_base & __io , char_type __fill , double __v ) const
{ return _M_insert_float ( __s , __io , __fill , char ( ) , __v ) ; }
#1152
template < typename _CharT , typename _OutIter >
_OutIter
num_put < _CharT , _OutIter > ::
do_put ( iter_type __s , ios_base & __io , char_type __fill ,
long double __v ) const
{ return _M_insert_float ( __s , __io , __fill , 'L' , __v ) ; }

template < typename _CharT , typename _OutIter >
_OutIter
num_put < _CharT , _OutIter > ::
do_put ( iter_type __s , ios_base & __io , char_type __fill ,
const void * __v ) const
{
const ios_base :: fmtflags __flags = __io . flags ( ) ;
const ios_base :: fmtflags __fmt = ~ ( ios_base :: basefield
| ios_base :: uppercase ) ;
__io . flags ( ( __flags & __fmt ) | ( ios_base :: hex | ios_base :: showbase ) ) ;

typedef __gnu_cxx :: __conditional_type < ( sizeof ( const void * )
<= sizeof ( unsigned long ) ) ,
unsigned long , unsigned long long > :: __type _UIntPtrType ;

__s = _M_insert_int ( __s , __io , __fill ,
reinterpret_cast < _UIntPtrType > ( __v ) ) ;
__io . flags ( __flags ) ;
return __s ;
}
#1189
template < typename _CharT , typename _Traits >
void
__pad < _CharT , _Traits > :: _S_pad ( ios_base & __io , _CharT __fill ,
_CharT * __news , const _CharT * __olds ,
streamsize __newlen , streamsize __oldlen )
{
const size_t __plen = static_cast < size_t > ( __newlen - __oldlen ) ;
const ios_base :: fmtflags __adjust = __io . flags ( ) & ios_base :: adjustfield ;


if ( __adjust == ios_base :: left )
{
_Traits :: copy ( __news , __olds , __oldlen ) ;
_Traits :: assign ( __news + __oldlen , __plen , __fill ) ;
return ;
}

size_t __mod = 0 ;
if ( __adjust == ios_base :: internal )
{



const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;

if ( __ctype . widen ( '-' ) == __olds [ 0 ]
|| __ctype . widen ( '+' ) == __olds [ 0 ] )
{
__news [ 0 ] = __olds [ 0 ] ;
__mod = 1 ;
++ __news ;
}
else if ( __ctype . widen ( '0' ) == __olds [ 0 ]
&& __oldlen > 1
&& ( __ctype . widen ( 'x' ) == __olds [ 1 ]
|| __ctype . widen ( 'X' ) == __olds [ 1 ] ) )
{
__news [ 0 ] = __olds [ 0 ] ;
__news [ 1 ] = __olds [ 1 ] ;
__mod = 2 ;
__news += 2 ;
}

}
_Traits :: assign ( __news , __plen , __fill ) ;
_Traits :: copy ( __news + __plen , __olds + __mod , __oldlen - __mod ) ;
}

template < typename _CharT >
_CharT *
__add_grouping ( _CharT * __s , _CharT __sep ,
const char * __gbeg , size_t __gsize ,
const _CharT * __first , const _CharT * __last )
{
size_t __idx = 0 ;
size_t __ctr = 0 ;

while ( __last - __first > __gbeg [ __idx ]
&& static_cast < signed char > ( __gbeg [ __idx ] ) > 0
&& __gbeg [ __idx ] != __gnu_cxx :: __numeric_traits < char > :: __max )
{
__last -= __gbeg [ __idx ] ;
__idx < __gsize - 1 ? ++ __idx : ++ __ctr ;
}

while ( __first != __last )
* __s ++ = * __first ++ ;

while ( __ctr -- )
{
* __s ++ = __sep ;
for ( char __i = __gbeg [ __idx ] ; __i > 0 ; -- __i )
* __s ++ = * __first ++ ;
}

while ( __idx -- )
{
* __s ++ = __sep ;
for ( char __i = __gbeg [ __idx ] ; __i > 0 ; -- __i )
* __s ++ = * __first ++ ;
}

return __s ;
}




extern template class numpunct < char > ;
extern template class numpunct_byname < char > ;
extern template class num_get < char > ;
extern template class num_put < char > ;
extern template class ctype_byname < char > ;

extern template
const ctype < char > &
use_facet < ctype < char > > ( const locale & ) ;

extern template
const numpunct < char > &
use_facet < numpunct < char > > ( const locale & ) ;

extern template
const num_put < char > &
use_facet < num_put < char > > ( const locale & ) ;

extern template
const num_get < char > &
use_facet < num_get < char > > ( const locale & ) ;

extern template
bool
has_facet < ctype < char > > ( const locale & ) ;

extern template
bool
has_facet < numpunct < char > > ( const locale & ) ;

extern template
bool
has_facet < num_put < char > > ( const locale & ) ;

extern template
bool
has_facet < num_get < char > > ( const locale & ) ;


extern template class numpunct < wchar_t > ;
extern template class numpunct_byname < wchar_t > ;
extern template class num_get < wchar_t > ;
extern template class num_put < wchar_t > ;
extern template class ctype_byname < wchar_t > ;

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

extern template
const numpunct < wchar_t > &
use_facet < numpunct < wchar_t > > ( const locale & ) ;

extern template
const num_put < wchar_t > &
use_facet < num_put < wchar_t > > ( const locale & ) ;

extern template
const num_get < wchar_t > &
use_facet < num_get < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < ctype < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < numpunct < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < num_put < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < num_get < wchar_t > > ( const locale & ) ;




}
#40 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_ios.h"
namespace std
{


template < typename _Facet >
inline const _Facet &
__check_facet ( const _Facet * __f )
{
if ( ! __f )
__throw_bad_cast ( ) ;
return * __f ;
}
#65
template < typename _CharT , typename _Traits >
class basic_ios : public ios_base
{
public :
#75
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 ;
#86
typedef ctype < _CharT > __ctype_type ;
typedef num_put < _CharT , ostreambuf_iterator < _CharT , _Traits > >
__num_put_type ;
typedef num_get < _CharT , istreambuf_iterator < _CharT , _Traits > >
__num_get_type ;



protected :
basic_ostream < _CharT , _Traits > * _M_tie ;
mutable char_type _M_fill ;
mutable bool _M_fill_init ;
basic_streambuf < _CharT , _Traits > * _M_streambuf ;


const __ctype_type * _M_ctype ;

const __num_put_type * _M_num_put ;

const __num_get_type * _M_num_get ;

public :
#115
operator void * ( ) const
{ return this -> fail ( ) ? 0 : const_cast < basic_ios * > ( this ) ; }

bool
operator ! ( ) const
{ return this -> fail ( ) ; }
#130
iostate
rdstate ( ) const
{ return _M_streambuf_state ; }
#141
void
clear ( iostate __state = goodbit ) ;
#150
void
setstate ( iostate __state )
{ this -> clear ( this -> rdstate ( ) | __state ) ; }




void
_M_setstate ( iostate __state )
{


_M_streambuf_state |= __state ;
if ( this -> exceptions ( ) & __state )
throw ;
}
#173
bool
good ( ) const
{ return this -> rdstate ( ) == 0 ; }
#183
bool
eof ( ) const
{ return ( this -> rdstate ( ) & eofbit ) != 0 ; }
#194
bool
fail ( ) const
{ return ( this -> rdstate ( ) & ( badbit | failbit ) ) != 0 ; }
#204
bool
bad ( ) const
{ return ( this -> rdstate ( ) & badbit ) != 0 ; }
#215
iostate
exceptions ( ) const
{ return _M_exception ; }
#250
void
exceptions ( iostate __except )
{
_M_exception = __except ;
this -> clear ( _M_streambuf_state ) ;
}
#263
explicit
basic_ios ( basic_streambuf < _CharT , _Traits > * __sb )
: ios_base ( ) , _M_tie ( 0 ) , _M_fill ( ) , _M_fill_init ( false ) , _M_streambuf ( 0 ) ,
_M_ctype ( 0 ) , _M_num_put ( 0 ) , _M_num_get ( 0 )
{ this -> init ( __sb ) ; }
#275
virtual
~ basic_ios ( ) { }
#288
basic_ostream < _CharT , _Traits > *
tie ( ) const
{ return _M_tie ; }
#300
basic_ostream < _CharT , _Traits > *
tie ( basic_ostream < _CharT , _Traits > * __tiestr )
{
basic_ostream < _CharT , _Traits > * __old = _M_tie ;
_M_tie = __tiestr ;
return __old ;
}
#314
basic_streambuf < _CharT , _Traits > *
rdbuf ( ) const
{ return _M_streambuf ; }
#340
basic_streambuf < _CharT , _Traits > *
rdbuf ( basic_streambuf < _CharT , _Traits > * __sb ) ;
#354
basic_ios &
copyfmt ( const basic_ios & __rhs ) ;
#363
char_type
fill ( ) const
{
if ( ! _M_fill_init )
{
_M_fill = this -> widen ( ' ' ) ;
_M_fill_init = true ;
}
return _M_fill ;
}
#383
char_type
fill ( char_type __ch )
{
char_type __old = this -> fill ( ) ;
_M_fill = __ch ;
return __old ;
}
#403
locale
imbue ( const locale & __loc ) ;
#423
char
narrow ( char_type __c , char __dfault ) const
{ return __check_facet ( _M_ctype ) . narrow ( __c , __dfault ) ; }
#442
char_type
widen ( char __c ) const
{ return __check_facet ( _M_ctype ) . widen ( __c ) ; }

protected :
#454
basic_ios ( )
: ios_base ( ) , _M_tie ( 0 ) , _M_fill ( char_type ( ) ) , _M_fill_init ( false ) ,
_M_streambuf ( 0 ) , _M_ctype ( 0 ) , _M_num_put ( 0 ) , _M_num_get ( 0 )
{ }
#465
void
init ( basic_streambuf < _CharT , _Traits > * __sb ) ;

void
_M_cache_locale ( const locale & __loc ) ;
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/basic_ios.tcc"
#33
#pragma GCC system_header

namespace std
{


template < typename _CharT , typename _Traits >
void
basic_ios < _CharT , _Traits > :: clear ( iostate __state )
{
if ( this -> rdbuf ( ) )
_M_streambuf_state = __state ;
else
_M_streambuf_state = __state | badbit ;
if ( this -> exceptions ( ) & this -> rdstate ( ) )
__throw_ios_failure ( ( "basic_ios::clear" ) ) ;
}

template < typename _CharT , typename _Traits >
basic_streambuf < _CharT , _Traits > *
basic_ios < _CharT , _Traits > :: rdbuf ( basic_streambuf < _CharT , _Traits > * __sb )
{
basic_streambuf < _CharT , _Traits > * __old = _M_streambuf ;
_M_streambuf = __sb ;
this -> clear ( ) ;
return __old ;
}

template < typename _CharT , typename _Traits >
basic_ios < _CharT , _Traits > &
basic_ios < _CharT , _Traits > :: copyfmt ( const basic_ios & __rhs )
{


if ( this != & __rhs )
{




_Words * __words = ( __rhs . _M_word_size <= _S_local_word_size ) ?
_M_local_word : new _Words [ __rhs . _M_word_size ] ;


_Callback_list * __cb = __rhs . _M_callbacks ;
if ( __cb )
__cb -> _M_add_reference ( ) ;
_M_call_callbacks ( erase_event ) ;
if ( _M_word != _M_local_word )
{
delete [ ] _M_word ;
_M_word = 0 ;
}
_M_dispose_callbacks ( ) ;


_M_callbacks = __cb ;
for ( int __i = 0 ; __i < __rhs . _M_word_size ; ++ __i )
__words [ __i ] = __rhs . _M_word [ __i ] ;
_M_word = __words ;
_M_word_size = __rhs . _M_word_size ;

this -> flags ( __rhs . flags ( ) ) ;
this -> width ( __rhs . width ( ) ) ;
this -> precision ( __rhs . precision ( ) ) ;
this -> tie ( __rhs . tie ( ) ) ;
this -> fill ( __rhs . fill ( ) ) ;
_M_ios_locale = __rhs . getloc ( ) ;
_M_cache_locale ( _M_ios_locale ) ;

_M_call_callbacks ( copyfmt_event ) ;


this -> exceptions ( __rhs . exceptions ( ) ) ;
}
return * this ;
}


template < typename _CharT , typename _Traits >
locale
basic_ios < _CharT , _Traits > :: imbue ( const locale & __loc )
{
locale __old ( this -> getloc ( ) ) ;
ios_base :: imbue ( __loc ) ;
_M_cache_locale ( __loc ) ;
if ( this -> rdbuf ( ) != 0 )
this -> rdbuf ( ) -> pubimbue ( __loc ) ;
return __old ;
}

template < typename _CharT , typename _Traits >
void
basic_ios < _CharT , _Traits > :: init ( basic_streambuf < _CharT , _Traits > * __sb )
{

ios_base :: _M_init ( ) ;


_M_cache_locale ( _M_ios_locale ) ;
#146
_M_fill = _CharT ( ) ;
_M_fill_init = false ;

_M_tie = 0 ;
_M_exception = goodbit ;
_M_streambuf = __sb ;
_M_streambuf_state = __sb ? goodbit : badbit ;
}

template < typename _CharT , typename _Traits >
void
basic_ios < _CharT , _Traits > :: _M_cache_locale ( const locale & __loc )
{
if ( has_facet < __ctype_type > ( __loc ) )
_M_ctype = & use_facet < __ctype_type > ( __loc ) ;
else
_M_ctype = 0 ;

if ( has_facet < __num_put_type > ( __loc ) )
_M_num_put = & use_facet < __num_put_type > ( __loc ) ;
else
_M_num_put = 0 ;

if ( has_facet < __num_get_type > ( __loc ) )
_M_num_get = & use_facet < __num_get_type > ( __loc ) ;
else
_M_num_get = 0 ;
}




extern template class basic_ios < char > ;


extern template class basic_ios < wchar_t > ;




}
#41 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ostream"
namespace std
{
#57
template < typename _CharT , typename _Traits >
class basic_ostream : virtual public basic_ios < _CharT , _Traits >
{
public :

typedef _CharT char_type ;
typedef typename _Traits :: int_type int_type ;
typedef typename _Traits :: pos_type pos_type ;
typedef typename _Traits :: off_type off_type ;
typedef _Traits traits_type ;


typedef basic_streambuf < _CharT , _Traits > __streambuf_type ;
typedef basic_ios < _CharT , _Traits > __ios_type ;
typedef basic_ostream < _CharT , _Traits > __ostream_type ;
typedef num_put < _CharT , ostreambuf_iterator < _CharT , _Traits > >
__num_put_type ;
typedef ctype < _CharT > __ctype_type ;
#83
explicit
basic_ostream ( __streambuf_type * __sb )
{ this -> init ( __sb ) ; }
#92
virtual
~ basic_ostream ( ) { }


class sentry ;
friend class sentry ;
#107
__ostream_type &
operator << ( __ostream_type & ( * __pf ) ( __ostream_type & ) )
{



return __pf ( * this ) ;
}

__ostream_type &
operator << ( __ios_type & ( * __pf ) ( __ios_type & ) )
{



__pf ( * this ) ;
return * this ;
}

__ostream_type &
operator << ( ios_base & ( * __pf ) ( ios_base & ) )
{



__pf ( * this ) ;
return * this ;
}
#165
__ostream_type &
operator << ( long __n )
{ return _M_insert ( __n ) ; }

__ostream_type &
operator << ( unsigned long __n )
{ return _M_insert ( __n ) ; }

__ostream_type &
operator << ( bool __n )
{ return _M_insert ( __n ) ; }

__ostream_type &
operator << ( short __n ) ;

__ostream_type &
operator << ( unsigned short __n )
{


return _M_insert ( static_cast < unsigned long > ( __n ) ) ;
}

__ostream_type &
operator << ( int __n ) ;

__ostream_type &
operator << ( unsigned int __n )
{


return _M_insert ( static_cast < unsigned long > ( __n ) ) ;
}


__ostream_type &
operator << ( long long __n )
{ return _M_insert ( __n ) ; }

__ostream_type &
operator << ( unsigned long long __n )
{ return _M_insert ( __n ) ; }
#219
__ostream_type &
operator << ( double __f )
{ return _M_insert ( __f ) ; }

__ostream_type &
operator << ( float __f )
{


return _M_insert ( static_cast < double > ( __f ) ) ;
}

__ostream_type &
operator << ( long double __f )
{ return _M_insert ( __f ) ; }
#244
__ostream_type &
operator << ( const void * __p )
{ return _M_insert ( __p ) ; }
#269
__ostream_type &
operator << ( __streambuf_type * __sb ) ;
#302
__ostream_type &
put ( char_type __c ) ;
#310
void
_M_write ( const char_type * __s , streamsize __n )
{
const streamsize __put = this -> rdbuf ( ) -> sputn ( __s , __n ) ;
if ( __put != __n )
this -> setstate ( ios_base :: badbit ) ;
}
#334
__ostream_type &
write ( const char_type * __s , streamsize __n ) ;
#347
__ostream_type &
flush ( ) ;
#357
pos_type
tellp ( ) ;
#368
__ostream_type &
seekp ( pos_type ) ;
#380
__ostream_type &
seekp ( off_type , ios_base :: seekdir ) ;

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

template < typename _ValueT >
__ostream_type &
_M_insert ( _ValueT __v ) ;
} ;
#399
template < typename _CharT , typename _Traits >
class basic_ostream < _CharT , _Traits > :: sentry
{

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

public :
#418
explicit
sentry ( basic_ostream < _CharT , _Traits > & __os ) ;
#428
~ sentry ( )
{

if ( bool ( _M_os . flags ( ) & ios_base :: unitbuf ) && ! uncaught_exception ( ) )
{

if ( _M_os . rdbuf ( ) && _M_os . rdbuf ( ) -> pubsync ( ) == - 1 )
_M_os . setstate ( ios_base :: badbit ) ;
}
}
#447
explicit

operator bool ( ) const
{ return _M_ok ; }
} ;
#469
template < typename _CharT , typename _Traits >
inline basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > & __out , _CharT __c )
{ return __ostream_insert ( __out , & __c , 1 ) ; }

template < typename _CharT , typename _Traits >
inline basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > & __out , char __c )
{ return ( __out << __out . widen ( __c ) ) ; }


template < class _Traits >
inline basic_ostream < char , _Traits > &
operator << ( basic_ostream < char , _Traits > & __out , char __c )
{ return __ostream_insert ( __out , & __c , 1 ) ; }


template < class _Traits >
inline basic_ostream < char , _Traits > &
operator << ( basic_ostream < char , _Traits > & __out , signed char __c )
{ return ( __out << static_cast < char > ( __c ) ) ; }

template < class _Traits >
inline basic_ostream < char , _Traits > &
operator << ( basic_ostream < char , _Traits > & __out , unsigned char __c )
{ return ( __out << static_cast < char > ( __c ) ) ; }
#511
template < typename _CharT , typename _Traits >
inline basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > & __out , const _CharT * __s )
{
if ( ! __s )
__out . setstate ( ios_base :: badbit ) ;
else
__ostream_insert ( __out , __s ,
static_cast < streamsize > ( _Traits :: length ( __s ) ) ) ;
return __out ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > & __out , const char * __s ) ;


template < class _Traits >
inline basic_ostream < char , _Traits > &
operator << ( basic_ostream < char , _Traits > & __out , const char * __s )
{
if ( ! __s )
__out . setstate ( ios_base :: badbit ) ;
else
__ostream_insert ( __out , __s ,
static_cast < streamsize > ( _Traits :: length ( __s ) ) ) ;
return __out ;
}


template < class _Traits >
inline basic_ostream < char , _Traits > &
operator << ( basic_ostream < char , _Traits > & __out , const signed char * __s )
{ return ( __out << reinterpret_cast < const char * > ( __s ) ) ; }

template < class _Traits >
inline basic_ostream < char , _Traits > &
operator << ( basic_ostream < char , _Traits > & __out , const unsigned char * __s )
{ return ( __out << reinterpret_cast < const char * > ( __s ) ) ; }
#562
template < typename _CharT , typename _Traits >
inline basic_ostream < _CharT , _Traits > &
endl ( basic_ostream < _CharT , _Traits > & __os )
{ return flush ( __os . put ( __os . widen ( '\n' ) ) ) ; }
#574
template < typename _CharT , typename _Traits >
inline basic_ostream < _CharT , _Traits > &
ends ( basic_ostream < _CharT , _Traits > & __os )
{ return __os . put ( _CharT ( ) ) ; }
#584
template < typename _CharT , typename _Traits >
inline basic_ostream < _CharT , _Traits > &
flush ( basic_ostream < _CharT , _Traits > & __os )
{ return __os . flush ( ) ; }
#600
template < typename _CharT , typename _Traits , typename _Tp >
inline basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > && __os , const _Tp & __x )
{ return ( __os << __x ) ; }



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/ostream.tcc"
#37
#pragma GCC system_header
#41
namespace std
{


template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > :: sentry ::
sentry ( basic_ostream < _CharT , _Traits > & __os )
: _M_ok ( false ) , _M_os ( __os )
{

if ( __os . tie ( ) && __os . good ( ) )
__os . tie ( ) -> flush ( ) ;

if ( __os . good ( ) )
_M_ok = true ;
else
__os . setstate ( ios_base :: failbit ) ;
}

template < typename _CharT , typename _Traits >
template < typename _ValueT >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
_M_insert ( _ValueT __v )
{
sentry __cerb ( * this ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const __num_put_type & __np = __check_facet ( this -> _M_num_put ) ;
if ( __np . put ( * this , * this , this -> fill ( ) , __v ) . failed ( ) )
__err |= ios_base :: badbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
operator << ( short __n )
{


const ios_base :: fmtflags __fmt = this -> flags ( ) & ios_base :: basefield ;
if ( __fmt == ios_base :: oct || __fmt == ios_base :: hex )
return _M_insert ( static_cast < long > ( static_cast < unsigned short > ( __n ) ) ) ;
else
return _M_insert ( static_cast < long > ( __n ) ) ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
operator << ( int __n )
{


const ios_base :: fmtflags __fmt = this -> flags ( ) & ios_base :: basefield ;
if ( __fmt == ios_base :: oct || __fmt == ios_base :: hex )
return _M_insert ( static_cast < long > ( static_cast < unsigned int > ( __n ) ) ) ;
else
return _M_insert ( static_cast < long > ( __n ) ) ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
operator << ( __streambuf_type * __sbin )
{
ios_base :: iostate __err = ios_base :: goodbit ;
sentry __cerb ( * this ) ;
if ( __cerb && __sbin )
{
try
{
if ( ! __copy_streambufs ( __sbin , this -> rdbuf ( ) ) )
__err |= ios_base :: failbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: failbit ) ; }
}
else if ( ! __sbin )
__err |= ios_base :: badbit ;
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
put ( char_type __c )
{
#157
sentry __cerb ( * this ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const int_type __put = this -> rdbuf ( ) -> sputc ( __c ) ;
if ( traits_type :: eq_int_type ( __put , traits_type :: eof ( ) ) )
__err |= ios_base :: badbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
write ( const _CharT * __s , streamsize __n )
{
#192
sentry __cerb ( * this ) ;
if ( __cerb )
{
try
{ _M_write ( __s , __n ) ; }
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
flush ( )
{



ios_base :: iostate __err = ios_base :: goodbit ;
try
{
if ( this -> rdbuf ( ) && this -> rdbuf ( ) -> pubsync ( ) == - 1 )
__err |= ios_base :: badbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
typename basic_ostream < _CharT , _Traits > :: pos_type
basic_ostream < _CharT , _Traits > ::
tellp ( )
{
pos_type __ret = pos_type ( - 1 ) ;
try
{
if ( ! this -> fail ( ) )
__ret = this -> rdbuf ( ) -> pubseekoff ( 0 , ios_base :: cur , ios_base :: out ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
return __ret ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
seekp ( pos_type __pos )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
if ( ! this -> fail ( ) )
{


const pos_type __p = this -> rdbuf ( ) -> pubseekpos ( __pos ,
ios_base :: out ) ;


if ( __p == pos_type ( off_type ( - 1 ) ) )
__err |= ios_base :: failbit ;
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
basic_ostream < _CharT , _Traits > ::
seekp ( off_type __off , ios_base :: seekdir __dir )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
if ( ! this -> fail ( ) )
{


const pos_type __p = this -> rdbuf ( ) -> pubseekoff ( __off , __dir ,
ios_base :: out ) ;


if ( __p == pos_type ( off_type ( - 1 ) ) )
__err |= ios_base :: failbit ;
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > & __out , const char * __s )
{
if ( ! __s )
__out . setstate ( ios_base :: badbit ) ;
else
{


const size_t __clen = char_traits < char > :: length ( __s ) ;
try
{
struct __ptr_guard
{
_CharT * __p ;
__ptr_guard ( _CharT * __ip ) : __p ( __ip ) { }
~ __ptr_guard ( ) { delete [ ] __p ; }
_CharT * __get ( ) { return __p ; }
} __pg ( new _CharT [ __clen ] ) ;

_CharT * __ws = __pg . __get ( ) ;
for ( size_t __i = 0 ; __i < __clen ; ++ __i )
__ws [ __i ] = __out . widen ( __s [ __i ] ) ;
__ostream_insert ( __out , __ws , __clen ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
__out . _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ __out . _M_setstate ( ios_base :: badbit ) ; }
}
return __out ;
}




extern template class basic_ostream < char > ;
extern template ostream & endl ( ostream & ) ;
extern template ostream & ends ( ostream & ) ;
extern template ostream & flush ( ostream & ) ;
extern template ostream & operator << ( ostream & , char ) ;
extern template ostream & operator << ( ostream & , unsigned char ) ;
extern template ostream & operator << ( ostream & , signed char ) ;
extern template ostream & operator << ( ostream & , const char * ) ;
extern template ostream & operator << ( ostream & , const unsigned char * ) ;
extern template ostream & operator << ( ostream & , const signed char * ) ;

extern template ostream & ostream :: _M_insert ( long ) ;
extern template ostream & ostream :: _M_insert ( unsigned long ) ;
extern template ostream & ostream :: _M_insert ( bool ) ;

extern template ostream & ostream :: _M_insert ( long long ) ;
extern template ostream & ostream :: _M_insert ( unsigned long long ) ;

extern template ostream & ostream :: _M_insert ( double ) ;
extern template ostream & ostream :: _M_insert ( long double ) ;
extern template ostream & ostream :: _M_insert ( const void * ) ;


extern template class basic_ostream < wchar_t > ;
extern template wostream & endl ( wostream & ) ;
extern template wostream & ends ( wostream & ) ;
extern template wostream & flush ( wostream & ) ;
extern template wostream & operator << ( wostream & , wchar_t ) ;
extern template wostream & operator << ( wostream & , char ) ;
extern template wostream & operator << ( wostream & , const wchar_t * ) ;
extern template wostream & operator << ( wostream & , const char * ) ;

extern template wostream & wostream :: _M_insert ( long ) ;
extern template wostream & wostream :: _M_insert ( unsigned long ) ;
extern template wostream & wostream :: _M_insert ( bool ) ;

extern template wostream & wostream :: _M_insert ( long long ) ;
extern template wostream & wostream :: _M_insert ( unsigned long long ) ;

extern template wostream & wostream :: _M_insert ( double ) ;
extern template wostream & wostream :: _M_insert ( long double ) ;
extern template wostream & wostream :: _M_insert ( const void * ) ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/istream"
#36
#pragma GCC system_header
#41
namespace std
{
#57
template < typename _CharT , typename _Traits >
class basic_istream : virtual public basic_ios < _CharT , _Traits >
{
public :

typedef _CharT char_type ;
typedef typename _Traits :: int_type int_type ;
typedef typename _Traits :: pos_type pos_type ;
typedef typename _Traits :: off_type off_type ;
typedef _Traits traits_type ;


typedef basic_streambuf < _CharT , _Traits > __streambuf_type ;
typedef basic_ios < _CharT , _Traits > __ios_type ;
typedef basic_istream < _CharT , _Traits > __istream_type ;
typedef num_get < _CharT , istreambuf_iterator < _CharT , _Traits > >
__num_get_type ;
typedef ctype < _CharT > __ctype_type ;

protected :





streamsize _M_gcount ;

public :
#92
explicit
basic_istream ( __streambuf_type * __sb )
: _M_gcount ( streamsize ( 0 ) )
{ this -> init ( __sb ) ; }
#102
virtual
~ basic_istream ( )
{ _M_gcount = streamsize ( 0 ) ; }


class sentry ;
friend class sentry ;
#119
__istream_type &
operator >> ( __istream_type & ( * __pf ) ( __istream_type & ) )
{ return __pf ( * this ) ; }

__istream_type &
operator >> ( __ios_type & ( * __pf ) ( __ios_type & ) )
{
__pf ( * this ) ;
return * this ;
}

__istream_type &
operator >> ( ios_base & ( * __pf ) ( ios_base & ) )
{
__pf ( * this ) ;
return * this ;
}
#167
__istream_type &
operator >> ( bool & __n )
{ return _M_extract ( __n ) ; }

__istream_type &
operator >> ( short & __n ) ;

__istream_type &
operator >> ( unsigned short & __n )
{ return _M_extract ( __n ) ; }

__istream_type &
operator >> ( int & __n ) ;

__istream_type &
operator >> ( unsigned int & __n )
{ return _M_extract ( __n ) ; }

__istream_type &
operator >> ( long & __n )
{ return _M_extract ( __n ) ; }

__istream_type &
operator >> ( unsigned long & __n )
{ return _M_extract ( __n ) ; }


__istream_type &
operator >> ( long long & __n )
{ return _M_extract ( __n ) ; }

__istream_type &
operator >> ( unsigned long long & __n )
{ return _M_extract ( __n ) ; }
#213
__istream_type &
operator >> ( float & __f )
{ return _M_extract ( __f ) ; }

__istream_type &
operator >> ( double & __f )
{ return _M_extract ( __f ) ; }

__istream_type &
operator >> ( long double & __f )
{ return _M_extract ( __f ) ; }
#234
__istream_type &
operator >> ( void * & __p )
{ return _M_extract ( __p ) ; }
#258
__istream_type &
operator >> ( __streambuf_type * __sb ) ;
#268
streamsize
gcount ( ) const
{ return _M_gcount ; }
#301
int_type
get ( ) ;
#315
__istream_type &
get ( char_type & __c ) ;
#342
__istream_type &
get ( char_type * __s , streamsize __n , char_type __delim ) ;
#353
__istream_type &
get ( char_type * __s , streamsize __n )
{ return this -> get ( __s , __n , this -> widen ( '\n' ) ) ; }
#376
__istream_type &
get ( __streambuf_type & __sb , char_type __delim ) ;
#386
__istream_type &
get ( __streambuf_type & __sb )
{ return this -> get ( __sb , this -> widen ( '\n' ) ) ; }
#415
__istream_type &
getline ( char_type * __s , streamsize __n , char_type __delim ) ;
#426
__istream_type &
getline ( char_type * __s , streamsize __n )
{ return this -> getline ( __s , __n , this -> widen ( '\n' ) ) ; }
#450
__istream_type &
ignore ( streamsize __n , int_type __delim ) ;

__istream_type &
ignore ( streamsize __n ) ;

__istream_type &
ignore ( ) ;
#467
int_type
peek ( ) ;
#485
__istream_type &
read ( char_type * __s , streamsize __n ) ;
#504
streamsize
readsome ( char_type * __s , streamsize __n ) ;
#521
__istream_type &
putback ( char_type __c ) ;
#537
__istream_type &
unget ( ) ;
#555
int
sync ( ) ;
#570
pos_type
tellg ( ) ;
#585
__istream_type &
seekg ( pos_type ) ;
#601
__istream_type &
seekg ( off_type , ios_base :: seekdir ) ;


protected :
basic_istream ( )
: _M_gcount ( streamsize ( 0 ) )
{ this -> init ( 0 ) ; }

template < typename _ValueT >
__istream_type &
_M_extract ( _ValueT & __v ) ;
} ;


template < >
basic_istream < char > &
basic_istream < char > ::
getline ( char_type * __s , streamsize __n , char_type __delim ) ;

template < >
basic_istream < char > &
basic_istream < char > ::
ignore ( streamsize __n ) ;

template < >
basic_istream < char > &
basic_istream < char > ::
ignore ( streamsize __n , int_type __delim ) ;


template < >
basic_istream < wchar_t > &
basic_istream < wchar_t > ::
getline ( char_type * __s , streamsize __n , char_type __delim ) ;

template < >
basic_istream < wchar_t > &
basic_istream < wchar_t > ::
ignore ( streamsize __n ) ;

template < >
basic_istream < wchar_t > &
basic_istream < wchar_t > ::
ignore ( streamsize __n , int_type __delim ) ;
#656
template < typename _CharT , typename _Traits >
class basic_istream < _CharT , _Traits > :: sentry
{

bool _M_ok ;

public :

typedef _Traits traits_type ;
typedef basic_streambuf < _CharT , _Traits > __streambuf_type ;
typedef basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: __ctype_type __ctype_type ;
typedef typename _Traits :: int_type __int_type ;
#692
explicit
sentry ( basic_istream < _CharT , _Traits > & __is , bool __noskipws = false ) ;
#703
explicit

operator bool ( ) const
{ return _M_ok ; }
} ;
#721
template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > & __in , _CharT & __c ) ;

template < class _Traits >
inline basic_istream < char , _Traits > &
operator >> ( basic_istream < char , _Traits > & __in , unsigned char & __c )
{ return ( __in >> reinterpret_cast < char & > ( __c ) ) ; }

template < class _Traits >
inline basic_istream < char , _Traits > &
operator >> ( basic_istream < char , _Traits > & __in , signed char & __c )
{ return ( __in >> reinterpret_cast < char & > ( __c ) ) ; }
#763
template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > & __in , _CharT * __s ) ;


template < >
basic_istream < char > &
operator >> ( basic_istream < char > & __in , char * __s ) ;

template < class _Traits >
inline basic_istream < char , _Traits > &
operator >> ( basic_istream < char , _Traits > & __in , unsigned char * __s )
{ return ( __in >> reinterpret_cast < char * > ( __s ) ) ; }

template < class _Traits >
inline basic_istream < char , _Traits > &
operator >> ( basic_istream < char , _Traits > & __in , signed char * __s )
{ return ( __in >> reinterpret_cast < char * > ( __s ) ) ; }
#794
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 ;
#819
explicit
basic_iostream ( basic_streambuf < _CharT , _Traits > * __sb )
: __istream_type ( __sb ) , __ostream_type ( __sb ) { }




virtual
~ basic_iostream ( ) { }

protected :
basic_iostream ( )
: __istream_type ( ) , __ostream_type ( ) { }
} ;
#854
template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
ws ( basic_istream < _CharT , _Traits > & __is ) ;
#870
template < typename _CharT , typename _Traits , typename _Tp >
inline basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > && __is , _Tp & __x )
{ return ( __is >> __x ) ; }



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/istream.tcc"
#37
#pragma GCC system_header
#41
namespace std
{


template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > :: sentry ::
sentry ( basic_istream < _CharT , _Traits > & __in , bool __noskip ) : _M_ok ( false )
{
ios_base :: iostate __err = ios_base :: goodbit ;
if ( __in . good ( ) )
{
if ( __in . tie ( ) )
__in . tie ( ) -> flush ( ) ;
if ( ! __noskip && bool ( __in . flags ( ) & ios_base :: skipws ) )
{
const __int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = __in . rdbuf ( ) ;
__int_type __c = __sb -> sgetc ( ) ;

const __ctype_type & __ct = __check_facet ( __in . _M_ctype ) ;
while ( ! traits_type :: eq_int_type ( __c , __eof )
&& __ct . is ( ctype_base :: space ,
traits_type :: to_char_type ( __c ) ) )
__c = __sb -> snextc ( ) ;




if ( traits_type :: eq_int_type ( __c , __eof ) )
__err |= ios_base :: eofbit ;
}
}

if ( __in . good ( ) && __err == ios_base :: goodbit )
_M_ok = true ;
else
{
__err |= ios_base :: failbit ;
__in . setstate ( __err ) ;
}
}

template < typename _CharT , typename _Traits >
template < typename _ValueT >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
_M_extract ( _ValueT & __v )
{
sentry __cerb ( * this , false ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const __num_get_type & __ng = __check_facet ( this -> _M_num_get ) ;
__ng . get ( * this , 0 , * this , __err , __v ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
operator >> ( short & __n )
{


sentry __cerb ( * this , false ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
long __l ;
const __num_get_type & __ng = __check_facet ( this -> _M_num_get ) ;
__ng . get ( * this , 0 , * this , __err , __l ) ;



if ( __l < __gnu_cxx :: __numeric_traits < short > :: __min )
{
__err |= ios_base :: failbit ;
__n = __gnu_cxx :: __numeric_traits < short > :: __min ;
}
else if ( __l > __gnu_cxx :: __numeric_traits < short > :: __max )
{
__err |= ios_base :: failbit ;
__n = __gnu_cxx :: __numeric_traits < short > :: __max ;
}
else
__n = short ( __l ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
operator >> ( int & __n )
{


sentry __cerb ( * this , false ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
long __l ;
const __num_get_type & __ng = __check_facet ( this -> _M_num_get ) ;
__ng . get ( * this , 0 , * this , __err , __l ) ;



if ( __l < __gnu_cxx :: __numeric_traits < int > :: __min )
{
__err |= ios_base :: failbit ;
__n = __gnu_cxx :: __numeric_traits < int > :: __min ;
}
else if ( __l > __gnu_cxx :: __numeric_traits < int > :: __max )
{
__err |= ios_base :: failbit ;
__n = __gnu_cxx :: __numeric_traits < int > :: __max ;
}
else
__n = int ( __l ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
operator >> ( __streambuf_type * __sbout )
{
ios_base :: iostate __err = ios_base :: goodbit ;
sentry __cerb ( * this , false ) ;
if ( __cerb && __sbout )
{
try
{
bool __ineof ;
if ( ! __copy_streambufs_eof ( this -> rdbuf ( ) , __sbout , __ineof ) )
__err |= ios_base :: failbit ;
if ( __ineof )
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: failbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: failbit ) ; }
}
else if ( ! __sbout )
__err |= ios_base :: failbit ;
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
typename basic_istream < _CharT , _Traits > :: int_type
basic_istream < _CharT , _Traits > ::
get ( void )
{
const int_type __eof = traits_type :: eof ( ) ;
int_type __c = __eof ;
_M_gcount = 0 ;
ios_base :: iostate __err = ios_base :: goodbit ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
try
{
__c = this -> rdbuf ( ) -> sbumpc ( ) ;

if ( ! traits_type :: eq_int_type ( __c , __eof ) )
_M_gcount = 1 ;
else
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
}
if ( ! _M_gcount )
__err |= ios_base :: failbit ;
if ( __err )
this -> setstate ( __err ) ;
return __c ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
get ( char_type & __c )
{
_M_gcount = 0 ;
ios_base :: iostate __err = ios_base :: goodbit ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
try
{
const int_type __cb = this -> rdbuf ( ) -> sbumpc ( ) ;

if ( ! traits_type :: eq_int_type ( __cb , traits_type :: eof ( ) ) )
{
_M_gcount = 1 ;
__c = traits_type :: to_char_type ( __cb ) ;
}
else
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
}
if ( ! _M_gcount )
__err |= ios_base :: failbit ;
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
get ( char_type * __s , streamsize __n , char_type __delim )
{
_M_gcount = 0 ;
ios_base :: iostate __err = ios_base :: goodbit ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
try
{
const int_type __idelim = traits_type :: to_int_type ( __delim ) ;
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = this -> rdbuf ( ) ;
int_type __c = __sb -> sgetc ( ) ;

while ( _M_gcount + 1 < __n
&& ! traits_type :: eq_int_type ( __c , __eof )
&& ! traits_type :: eq_int_type ( __c , __idelim ) )
{
* __s ++ = traits_type :: to_char_type ( __c ) ;
++ _M_gcount ;
__c = __sb -> snextc ( ) ;
}
if ( traits_type :: eq_int_type ( __c , __eof ) )
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
}


if ( __n > 0 )
* __s = char_type ( ) ;
if ( ! _M_gcount )
__err |= ios_base :: failbit ;
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
get ( __streambuf_type & __sb , char_type __delim )
{
_M_gcount = 0 ;
ios_base :: iostate __err = ios_base :: goodbit ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
try
{
const int_type __idelim = traits_type :: to_int_type ( __delim ) ;
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __this_sb = this -> rdbuf ( ) ;
int_type __c = __this_sb -> sgetc ( ) ;
char_type __c2 = traits_type :: to_char_type ( __c ) ;

while ( ! traits_type :: eq_int_type ( __c , __eof )
&& ! traits_type :: eq_int_type ( __c , __idelim )
&& ! traits_type :: eq_int_type ( __sb . sputc ( __c2 ) , __eof ) )
{
++ _M_gcount ;
__c = __this_sb -> snextc ( ) ;
__c2 = traits_type :: to_char_type ( __c ) ;
}
if ( traits_type :: eq_int_type ( __c , __eof ) )
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
}
if ( ! _M_gcount )
__err |= ios_base :: failbit ;
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
getline ( char_type * __s , streamsize __n , char_type __delim )
{
_M_gcount = 0 ;
ios_base :: iostate __err = ios_base :: goodbit ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
try
{
const int_type __idelim = traits_type :: to_int_type ( __delim ) ;
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = this -> rdbuf ( ) ;
int_type __c = __sb -> sgetc ( ) ;

while ( _M_gcount + 1 < __n
&& ! traits_type :: eq_int_type ( __c , __eof )
&& ! traits_type :: eq_int_type ( __c , __idelim ) )
{
* __s ++ = traits_type :: to_char_type ( __c ) ;
__c = __sb -> snextc ( ) ;
++ _M_gcount ;
}
if ( traits_type :: eq_int_type ( __c , __eof ) )
__err |= ios_base :: eofbit ;
else
{
if ( traits_type :: eq_int_type ( __c , __idelim ) )
{
__sb -> sbumpc ( ) ;
++ _M_gcount ;
}
else
__err |= ios_base :: failbit ;
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
}


if ( __n > 0 )
* __s = char_type ( ) ;
if ( ! _M_gcount )
__err |= ios_base :: failbit ;
if ( __err )
this -> setstate ( __err ) ;
return * this ;
}




template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
ignore ( void )
{
_M_gcount = 0 ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = this -> rdbuf ( ) ;

if ( traits_type :: eq_int_type ( __sb -> sbumpc ( ) , __eof ) )
__err |= ios_base :: eofbit ;
else
_M_gcount = 1 ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
ignore ( streamsize __n )
{
_M_gcount = 0 ;
sentry __cerb ( * this , true ) ;
if ( __cerb && __n > 0 )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = this -> rdbuf ( ) ;
int_type __c = __sb -> sgetc ( ) ;
#513
bool __large_ignore = false ;
while ( true )
{
while ( _M_gcount < __n
&& ! traits_type :: eq_int_type ( __c , __eof ) )
{
++ _M_gcount ;
__c = __sb -> snextc ( ) ;
}
if ( __n == __gnu_cxx :: __numeric_traits < streamsize > :: __max
&& ! traits_type :: eq_int_type ( __c , __eof ) )
{
_M_gcount =
__gnu_cxx :: __numeric_traits < streamsize > :: __min ;
__large_ignore = true ;
}
else
break ;
}

if ( __large_ignore )
_M_gcount = __gnu_cxx :: __numeric_traits < streamsize > :: __max ;

if ( traits_type :: eq_int_type ( __c , __eof ) )
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
ignore ( streamsize __n , int_type __delim )
{
_M_gcount = 0 ;
sentry __cerb ( * this , true ) ;
if ( __cerb && __n > 0 )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = this -> rdbuf ( ) ;
int_type __c = __sb -> sgetc ( ) ;


bool __large_ignore = false ;
while ( true )
{
while ( _M_gcount < __n
&& ! traits_type :: eq_int_type ( __c , __eof )
&& ! traits_type :: eq_int_type ( __c , __delim ) )
{
++ _M_gcount ;
__c = __sb -> snextc ( ) ;
}
if ( __n == __gnu_cxx :: __numeric_traits < streamsize > :: __max
&& ! traits_type :: eq_int_type ( __c , __eof )
&& ! traits_type :: eq_int_type ( __c , __delim ) )
{
_M_gcount =
__gnu_cxx :: __numeric_traits < streamsize > :: __min ;
__large_ignore = true ;
}
else
break ;
}

if ( __large_ignore )
_M_gcount = __gnu_cxx :: __numeric_traits < streamsize > :: __max ;

if ( traits_type :: eq_int_type ( __c , __eof ) )
__err |= ios_base :: eofbit ;
else if ( traits_type :: eq_int_type ( __c , __delim ) )
{
if ( _M_gcount
< __gnu_cxx :: __numeric_traits < streamsize > :: __max )
++ _M_gcount ;
__sb -> sbumpc ( ) ;
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
typename basic_istream < _CharT , _Traits > :: int_type
basic_istream < _CharT , _Traits > ::
peek ( void )
{
int_type __c = traits_type :: eof ( ) ;
_M_gcount = 0 ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
__c = this -> rdbuf ( ) -> sgetc ( ) ;
if ( traits_type :: eq_int_type ( __c , traits_type :: eof ( ) ) )
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return __c ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
read ( char_type * __s , streamsize __n )
{
_M_gcount = 0 ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
_M_gcount = this -> rdbuf ( ) -> sgetn ( __s , __n ) ;
if ( _M_gcount != __n )
__err |= ( ios_base :: eofbit | ios_base :: failbit ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
streamsize
basic_istream < _CharT , _Traits > ::
readsome ( char_type * __s , streamsize __n )
{
_M_gcount = 0 ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{

const streamsize __num = this -> rdbuf ( ) -> in_avail ( ) ;
if ( __num > 0 )
_M_gcount = this -> rdbuf ( ) -> sgetn ( __s , std :: min ( __num , __n ) ) ;
else if ( __num == - 1 )
__err |= ios_base :: eofbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return _M_gcount ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
putback ( char_type __c )
{


_M_gcount = 0 ;

this -> clear ( this -> rdstate ( ) & ~ ios_base :: eofbit ) ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = this -> rdbuf ( ) ;
if ( ! __sb
|| traits_type :: eq_int_type ( __sb -> sputbackc ( __c ) , __eof ) )
__err |= ios_base :: badbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
unget ( void )
{


_M_gcount = 0 ;

this -> clear ( this -> rdstate ( ) & ~ ios_base :: eofbit ) ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const int_type __eof = traits_type :: eof ( ) ;
__streambuf_type * __sb = this -> rdbuf ( ) ;
if ( ! __sb
|| traits_type :: eq_int_type ( __sb -> sungetc ( ) , __eof ) )
__err |= ios_base :: badbit ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
int
basic_istream < _CharT , _Traits > ::
sync ( void )
{


int __ret = - 1 ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
__streambuf_type * __sb = this -> rdbuf ( ) ;
if ( __sb )
{
if ( __sb -> pubsync ( ) == - 1 )
__err |= ios_base :: badbit ;
else
__ret = 0 ;
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return __ret ;
}

template < typename _CharT , typename _Traits >
typename basic_istream < _CharT , _Traits > :: pos_type
basic_istream < _CharT , _Traits > ::
tellg ( void )
{


pos_type __ret = pos_type ( - 1 ) ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
try
{
if ( ! this -> fail ( ) )
__ret = this -> rdbuf ( ) -> pubseekoff ( 0 , ios_base :: cur ,
ios_base :: in ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
}
return __ret ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
seekg ( pos_type __pos )
{



this -> clear ( this -> rdstate ( ) & ~ ios_base :: eofbit ) ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
if ( ! this -> fail ( ) )
{

const pos_type __p = this -> rdbuf ( ) -> pubseekpos ( __pos ,
ios_base :: in ) ;


if ( __p == pos_type ( off_type ( - 1 ) ) )
__err |= ios_base :: failbit ;
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
basic_istream < _CharT , _Traits > ::
seekg ( off_type __off , ios_base :: seekdir __dir )
{



this -> clear ( this -> rdstate ( ) & ~ ios_base :: eofbit ) ;
sentry __cerb ( * this , true ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
if ( ! this -> fail ( ) )
{

const pos_type __p = this -> rdbuf ( ) -> pubseekoff ( __off , __dir ,
ios_base :: in ) ;


if ( __p == pos_type ( off_type ( - 1 ) ) )
__err |= ios_base :: failbit ;
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
this -> _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ this -> _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
this -> setstate ( __err ) ;
}
return * this ;
}


template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > & __in , _CharT & __c )
{
typedef basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: int_type __int_type ;

typename __istream_type :: sentry __cerb ( __in , false ) ;
if ( __cerb )
{
ios_base :: iostate __err = ios_base :: goodbit ;
try
{
const __int_type __cb = __in . rdbuf ( ) -> sbumpc ( ) ;
if ( ! _Traits :: eq_int_type ( __cb , _Traits :: eof ( ) ) )
__c = _Traits :: to_char_type ( __cb ) ;
else
__err |= ( ios_base :: eofbit | ios_base :: failbit ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
__in . _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ __in . _M_setstate ( ios_base :: badbit ) ; }
if ( __err )
__in . setstate ( __err ) ;
}
return __in ;
}

template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > & __in , _CharT * __s )
{
typedef basic_istream < _CharT , _Traits > __istream_type ;
typedef basic_streambuf < _CharT , _Traits > __streambuf_type ;
typedef typename _Traits :: int_type int_type ;
typedef _CharT char_type ;
typedef ctype < _CharT > __ctype_type ;

streamsize __extracted = 0 ;
ios_base :: iostate __err = ios_base :: goodbit ;
typename __istream_type :: sentry __cerb ( __in , false ) ;
if ( __cerb )
{
try
{

streamsize __num = __in . width ( ) ;
if ( __num <= 0 )
__num = __gnu_cxx :: __numeric_traits < streamsize > :: __max ;

const __ctype_type & __ct = use_facet < __ctype_type > ( __in . getloc ( ) ) ;

const int_type __eof = _Traits :: eof ( ) ;
__streambuf_type * __sb = __in . rdbuf ( ) ;
int_type __c = __sb -> sgetc ( ) ;

while ( __extracted < __num - 1
&& ! _Traits :: eq_int_type ( __c , __eof )
&& ! __ct . is ( ctype_base :: space ,
_Traits :: to_char_type ( __c ) ) )
{
* __s ++ = _Traits :: to_char_type ( __c ) ;
++ __extracted ;
__c = __sb -> snextc ( ) ;
}
if ( _Traits :: eq_int_type ( __c , __eof ) )
__err |= ios_base :: eofbit ;



* __s = char_type ( ) ;
__in . width ( 0 ) ;
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
__in . _M_setstate ( ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ __in . _M_setstate ( ios_base :: badbit ) ; }
}
if ( ! __extracted )
__err |= ios_base :: failbit ;
if ( __err )
__in . setstate ( __err ) ;
return __in ;
}


template < typename _CharT , typename _Traits >
basic_istream < _CharT , _Traits > &
ws ( basic_istream < _CharT , _Traits > & __in )
{
typedef basic_istream < _CharT , _Traits > __istream_type ;
typedef basic_streambuf < _CharT , _Traits > __streambuf_type ;
typedef typename __istream_type :: int_type __int_type ;
typedef ctype < _CharT > __ctype_type ;

const __ctype_type & __ct = use_facet < __ctype_type > ( __in . getloc ( ) ) ;
const __int_type __eof = _Traits :: eof ( ) ;
__streambuf_type * __sb = __in . rdbuf ( ) ;
__int_type __c = __sb -> sgetc ( ) ;

while ( ! _Traits :: eq_int_type ( __c , __eof )
&& __ct . is ( ctype_base :: space , _Traits :: to_char_type ( __c ) ) )
__c = __sb -> snextc ( ) ;

if ( _Traits :: eq_int_type ( __c , __eof ) )
__in . setstate ( ios_base :: eofbit ) ;
return __in ;
}




extern template class basic_istream < char > ;
extern template istream & ws ( istream & ) ;
extern template istream & operator >> ( istream & , char & ) ;
extern template istream & operator >> ( istream & , char * ) ;
extern template istream & operator >> ( istream & , unsigned char & ) ;
extern template istream & operator >> ( istream & , signed char & ) ;
extern template istream & operator >> ( istream & , unsigned char * ) ;
extern template istream & operator >> ( istream & , signed char * ) ;

extern template istream & istream :: _M_extract ( unsigned short & ) ;
extern template istream & istream :: _M_extract ( unsigned int & ) ;
extern template istream & istream :: _M_extract ( long & ) ;
extern template istream & istream :: _M_extract ( unsigned long & ) ;
extern template istream & istream :: _M_extract ( bool & ) ;

extern template istream & istream :: _M_extract ( long long & ) ;
extern template istream & istream :: _M_extract ( unsigned long long & ) ;

extern template istream & istream :: _M_extract ( float & ) ;
extern template istream & istream :: _M_extract ( double & ) ;
extern template istream & istream :: _M_extract ( long double & ) ;
extern template istream & istream :: _M_extract ( void * & ) ;

extern template class basic_iostream < char > ;


extern template class basic_istream < wchar_t > ;
extern template wistream & ws ( wistream & ) ;
extern template wistream & operator >> ( wistream & , wchar_t & ) ;
extern template wistream & operator >> ( wistream & , wchar_t * ) ;

extern template wistream & wistream :: _M_extract ( unsigned short & ) ;
extern template wistream & wistream :: _M_extract ( unsigned int & ) ;
extern template wistream & wistream :: _M_extract ( long & ) ;
extern template wistream & wistream :: _M_extract ( unsigned long & ) ;
extern template wistream & wistream :: _M_extract ( bool & ) ;

extern template wistream & wistream :: _M_extract ( long long & ) ;
extern template wistream & wistream :: _M_extract ( unsigned long long & ) ;

extern template wistream & wistream :: _M_extract ( float & ) ;
extern template wistream & wistream :: _M_extract ( double & ) ;
extern template wistream & wistream :: _M_extract ( long double & ) ;
extern template wistream & wistream :: _M_extract ( void * & ) ;

extern template class basic_iostream < wchar_t > ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stream_iterator.h"
#33
#pragma GCC system_header
#37
namespace std
{
#47
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 :

constexpr istream_iterator ( )
: _M_stream ( 0 ) , _M_value ( ) , _M_ok ( false ) { }


istream_iterator ( istream_type & __s )
: _M_stream ( & __s )
{ _M_read ( ) ; }

istream_iterator ( const istream_iterator & __obj )
: _M_stream ( __obj . _M_stream ) , _M_value ( __obj . _M_value ) ,
_M_ok ( __obj . _M_ok )
{ }

const _Tp &
operator * ( ) const
{


;
return _M_value ;
}

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

istream_iterator &
operator ++ ( )
{


;
_M_read ( ) ;
return * this ;
}

istream_iterator
operator ++ ( int )
{


;
istream_iterator __tmp = * this ;
_M_read ( ) ;
return __tmp ;
}

bool
_M_equal ( const istream_iterator & __x ) const
{ return ( _M_ok == __x . _M_ok ) && ( ! _M_ok || _M_stream == __x . _M_stream ) ; }

private :
void
_M_read ( )
{
_M_ok = ( _M_stream && * _M_stream ) ? true : false ;
if ( _M_ok )
{
* _M_stream >> _M_value ;
_M_ok = * _M_stream ? true : false ;
}
}
} ;


template < typename _Tp , typename _CharT , typename _Traits , typename _Dist >
inline bool
operator == ( const istream_iterator < _Tp , _CharT , _Traits , _Dist > & __x ,
const istream_iterator < _Tp , _CharT , _Traits , _Dist > & __y )
{ return __x . _M_equal ( __y ) ; }


template < class _Tp , class _CharT , class _Traits , class _Dist >
inline bool
operator != ( const istream_iterator < _Tp , _CharT , _Traits , _Dist > & __x ,
const istream_iterator < _Tp , _CharT , _Traits , _Dist > & __y )
{ return ! __x . _M_equal ( __y ) ; }
#152
template < typename _Tp , typename _CharT = char ,
typename _Traits = char_traits < _CharT > >
class ostream_iterator
: public iterator < output_iterator_tag , void , void , void , void >
{
public :


typedef _CharT char_type ;
typedef _Traits traits_type ;
typedef basic_ostream < _CharT , _Traits > ostream_type ;


private :
ostream_type * _M_stream ;
const _CharT * _M_string ;

public :

ostream_iterator ( ostream_type & __s ) : _M_stream ( & __s ) , _M_string ( 0 ) { }
#183
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 ; }
} ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/algorithm"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_algo.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/algorithmfwd.h"
#33
#pragma GCC system_header
#42
namespace std
{
#194
template < typename _IIter , typename _Predicate >
bool
all_of ( _IIter , _IIter , _Predicate ) ;

template < typename _IIter , typename _Predicate >
bool
any_of ( _IIter , _IIter , _Predicate ) ;


template < typename _FIter , typename _Tp >
bool
binary_search ( _FIter , _FIter , const _Tp & ) ;

template < typename _FIter , typename _Tp , typename _Compare >
bool
binary_search ( _FIter , _FIter , const _Tp & , _Compare ) ;

template < typename _IIter , typename _OIter >
_OIter
copy ( _IIter , _IIter , _OIter ) ;

template < typename _BIter1 , typename _BIter2 >
_BIter2
copy_backward ( _BIter1 , _BIter1 , _BIter2 ) ;


template < typename _IIter , typename _OIter , typename _Predicate >
_OIter
copy_if ( _IIter , _IIter , _OIter , _Predicate ) ;

template < typename _IIter , typename _Size , typename _OIter >
_OIter
copy_n ( _IIter , _Size , _OIter ) ;





template < typename _FIter , typename _Tp >
pair < _FIter , _FIter >
equal_range ( _FIter , _FIter , const _Tp & ) ;

template < typename _FIter , typename _Tp , typename _Compare >
pair < _FIter , _FIter >
equal_range ( _FIter , _FIter , const _Tp & , _Compare ) ;

template < typename _FIter , typename _Tp >
void
fill ( _FIter , _FIter , const _Tp & ) ;

template < typename _OIter , typename _Size , typename _Tp >
_OIter
fill_n ( _OIter , _Size , const _Tp & ) ;



template < typename _FIter1 , typename _FIter2 >
_FIter1
find_end ( _FIter1 , _FIter1 , _FIter2 , _FIter2 ) ;

template < typename _FIter1 , typename _FIter2 , typename _BinaryPredicate >
_FIter1
find_end ( _FIter1 , _FIter1 , _FIter2 , _FIter2 , _BinaryPredicate ) ;





template < typename _IIter , typename _Predicate >
_IIter
find_if_not ( _IIter , _IIter , _Predicate ) ;
#271
template < typename _IIter1 , typename _IIter2 >
bool
includes ( _IIter1 , _IIter1 , _IIter2 , _IIter2 ) ;

template < typename _IIter1 , typename _IIter2 , typename _Compare >
bool
includes ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _Compare ) ;

template < typename _BIter >
void
inplace_merge ( _BIter , _BIter , _BIter ) ;

template < typename _BIter , typename _Compare >
void
inplace_merge ( _BIter , _BIter , _BIter , _Compare ) ;


template < typename _RAIter >
bool
is_heap ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
bool
is_heap ( _RAIter , _RAIter , _Compare ) ;

template < typename _RAIter >
_RAIter
is_heap_until ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
_RAIter
is_heap_until ( _RAIter , _RAIter , _Compare ) ;

template < typename _IIter , typename _Predicate >
bool
is_partitioned ( _IIter , _IIter , _Predicate ) ;

template < typename _FIter1 , typename _FIter2 >
bool
is_permutation ( _FIter1 , _FIter1 , _FIter2 ) ;

template < typename _FIter1 , typename _FIter2 ,
typename _BinaryPredicate >
bool
is_permutation ( _FIter1 , _FIter1 , _FIter2 , _BinaryPredicate ) ;

template < typename _FIter >
bool
is_sorted ( _FIter , _FIter ) ;

template < typename _FIter , typename _Compare >
bool
is_sorted ( _FIter , _FIter , _Compare ) ;

template < typename _FIter >
_FIter
is_sorted_until ( _FIter , _FIter ) ;

template < typename _FIter , typename _Compare >
_FIter
is_sorted_until ( _FIter , _FIter , _Compare ) ;


template < typename _FIter1 , typename _FIter2 >
void
iter_swap ( _FIter1 , _FIter2 ) ;

template < typename _FIter , typename _Tp >
_FIter
lower_bound ( _FIter , _FIter , const _Tp & ) ;

template < typename _FIter , typename _Tp , typename _Compare >
_FIter
lower_bound ( _FIter , _FIter , const _Tp & , _Compare ) ;

template < typename _RAIter >
void
make_heap ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
make_heap ( _RAIter , _RAIter , _Compare ) ;

template < typename _Tp >
const _Tp &
max ( const _Tp & , const _Tp & ) ;

template < typename _Tp , typename _Compare >
const _Tp &
max ( const _Tp & , const _Tp & , _Compare ) ;




template < typename _Tp >
const _Tp &
min ( const _Tp & , const _Tp & ) ;

template < typename _Tp , typename _Compare >
const _Tp &
min ( const _Tp & , const _Tp & , _Compare ) ;




template < typename _Tp >
pair < const _Tp & , const _Tp & >
minmax ( const _Tp & , const _Tp & ) ;

template < typename _Tp , typename _Compare >
pair < const _Tp & , const _Tp & >
minmax ( const _Tp & , const _Tp & , _Compare ) ;

template < typename _FIter >
pair < _FIter , _FIter >
minmax_element ( _FIter , _FIter ) ;

template < typename _FIter , typename _Compare >
pair < _FIter , _FIter >
minmax_element ( _FIter , _FIter , _Compare ) ;

template < typename _Tp >
_Tp
min ( initializer_list < _Tp > ) ;

template < typename _Tp , typename _Compare >
_Tp
min ( initializer_list < _Tp > , _Compare ) ;

template < typename _Tp >
_Tp
max ( initializer_list < _Tp > ) ;

template < typename _Tp , typename _Compare >
_Tp
max ( initializer_list < _Tp > , _Compare ) ;

template < typename _Tp >
pair < _Tp , _Tp >
minmax ( initializer_list < _Tp > ) ;

template < typename _Tp , typename _Compare >
pair < _Tp , _Tp >
minmax ( initializer_list < _Tp > , _Compare ) ;




template < typename _BIter >
bool
next_permutation ( _BIter , _BIter ) ;

template < typename _BIter , typename _Compare >
bool
next_permutation ( _BIter , _BIter , _Compare ) ;


template < typename _IIter , typename _Predicate >
bool
none_of ( _IIter , _IIter , _Predicate ) ;





template < typename _IIter , typename _RAIter >
_RAIter
partial_sort_copy ( _IIter , _IIter , _RAIter , _RAIter ) ;

template < typename _IIter , typename _RAIter , typename _Compare >
_RAIter
partial_sort_copy ( _IIter , _IIter , _RAIter , _RAIter , _Compare ) ;




template < typename _IIter , typename _OIter1 ,
typename _OIter2 , typename _Predicate >
pair < _OIter1 , _OIter2 >
partition_copy ( _IIter , _IIter , _OIter1 , _OIter2 , _Predicate ) ;

template < typename _FIter , typename _Predicate >
_FIter
partition_point ( _FIter , _FIter , _Predicate ) ;


template < typename _RAIter >
void
pop_heap ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
pop_heap ( _RAIter , _RAIter , _Compare ) ;

template < typename _BIter >
bool
prev_permutation ( _BIter , _BIter ) ;

template < typename _BIter , typename _Compare >
bool
prev_permutation ( _BIter , _BIter , _Compare ) ;

template < typename _RAIter >
void
push_heap ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
push_heap ( _RAIter , _RAIter , _Compare ) ;



template < typename _FIter , typename _Tp >
_FIter
remove ( _FIter , _FIter , const _Tp & ) ;

template < typename _FIter , typename _Predicate >
_FIter
remove_if ( _FIter , _FIter , _Predicate ) ;

template < typename _IIter , typename _OIter , typename _Tp >
_OIter
remove_copy ( _IIter , _IIter , _OIter , const _Tp & ) ;

template < typename _IIter , typename _OIter , typename _Predicate >
_OIter
remove_copy_if ( _IIter , _IIter , _OIter , _Predicate ) ;



template < typename _IIter , typename _OIter , typename _Tp >
_OIter
replace_copy ( _IIter , _IIter , _OIter , const _Tp & , const _Tp & ) ;

template < typename _Iter , typename _OIter , typename _Predicate , typename _Tp >
_OIter
replace_copy_if ( _Iter , _Iter , _OIter , _Predicate , const _Tp & ) ;



template < typename _BIter >
void
reverse ( _BIter , _BIter ) ;

template < typename _BIter , typename _OIter >
_OIter
reverse_copy ( _BIter , _BIter , _OIter ) ;

template < typename _FIter >
void
rotate ( _FIter , _FIter , _FIter ) ;

template < typename _FIter , typename _OIter >
_OIter
rotate_copy ( _FIter , _FIter , _FIter , _OIter ) ;
#535
template < typename _RAIter , typename _UGenerator >
void
shuffle ( _RAIter , _RAIter , _UGenerator && ) ;


template < typename _RAIter >
void
sort_heap ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
sort_heap ( _RAIter , _RAIter , _Compare ) ;

template < typename _BIter , typename _Predicate >
_BIter
stable_partition ( _BIter , _BIter , _Predicate ) ;

template < typename _Tp >
void
swap ( _Tp & , _Tp & )

noexcept ( __and_ < is_nothrow_move_constructible < _Tp > ,
is_nothrow_move_assignable < _Tp >> :: value )

;

template < typename _Tp , size_t _Nm >
void
swap ( _Tp ( & __a ) [ _Nm ] , _Tp ( & __b ) [ _Nm ] )

noexcept ( noexcept ( swap ( * __a , * __b ) ) )

;

template < typename _FIter1 , typename _FIter2 >
_FIter2
swap_ranges ( _FIter1 , _FIter1 , _FIter2 ) ;



template < typename _FIter >
_FIter
unique ( _FIter , _FIter ) ;

template < typename _FIter , typename _BinaryPredicate >
_FIter
unique ( _FIter , _FIter , _BinaryPredicate ) ;



template < typename _FIter , typename _Tp >
_FIter
upper_bound ( _FIter , _FIter , const _Tp & ) ;

template < typename _FIter , typename _Tp , typename _Compare >
_FIter
upper_bound ( _FIter , _FIter , const _Tp & , _Compare ) ;





template < typename _FIter >
_FIter
adjacent_find ( _FIter , _FIter ) ;

template < typename _FIter , typename _BinaryPredicate >
_FIter
adjacent_find ( _FIter , _FIter , _BinaryPredicate ) ;

template < typename _IIter , typename _Tp >
typename iterator_traits < _IIter > :: difference_type
count ( _IIter , _IIter , const _Tp & ) ;

template < typename _IIter , typename _Predicate >
typename iterator_traits < _IIter > :: difference_type
count_if ( _IIter , _IIter , _Predicate ) ;

template < typename _IIter1 , typename _IIter2 >
bool
equal ( _IIter1 , _IIter1 , _IIter2 ) ;

template < typename _IIter1 , typename _IIter2 , typename _BinaryPredicate >
bool
equal ( _IIter1 , _IIter1 , _IIter2 , _BinaryPredicate ) ;

template < typename _IIter , typename _Tp >
_IIter
find ( _IIter , _IIter , const _Tp & ) ;

template < typename _FIter1 , typename _FIter2 >
_FIter1
find_first_of ( _FIter1 , _FIter1 , _FIter2 , _FIter2 ) ;

template < typename _FIter1 , typename _FIter2 , typename _BinaryPredicate >
_FIter1
find_first_of ( _FIter1 , _FIter1 , _FIter2 , _FIter2 , _BinaryPredicate ) ;

template < typename _IIter , typename _Predicate >
_IIter
find_if ( _IIter , _IIter , _Predicate ) ;

template < typename _IIter , typename _Funct >
_Funct
for_each ( _IIter , _IIter , _Funct ) ;

template < typename _FIter , typename _Generator >
void
generate ( _FIter , _FIter , _Generator ) ;

template < typename _OIter , typename _Size , typename _Generator >
_OIter
generate_n ( _OIter , _Size , _Generator ) ;

template < typename _IIter1 , typename _IIter2 >
bool
lexicographical_compare ( _IIter1 , _IIter1 , _IIter2 , _IIter2 ) ;

template < typename _IIter1 , typename _IIter2 , typename _Compare >
bool
lexicographical_compare ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _Compare ) ;

template < typename _FIter >
_FIter
max_element ( _FIter , _FIter ) ;

template < typename _FIter , typename _Compare >
_FIter
max_element ( _FIter , _FIter , _Compare ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter >
_OIter
merge ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter ,
typename _Compare >
_OIter
merge ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter , _Compare ) ;

template < typename _FIter >
_FIter
min_element ( _FIter , _FIter ) ;

template < typename _FIter , typename _Compare >
_FIter
min_element ( _FIter , _FIter , _Compare ) ;

template < typename _IIter1 , typename _IIter2 >
pair < _IIter1 , _IIter2 >
mismatch ( _IIter1 , _IIter1 , _IIter2 ) ;

template < typename _IIter1 , typename _IIter2 , typename _BinaryPredicate >
pair < _IIter1 , _IIter2 >
mismatch ( _IIter1 , _IIter1 , _IIter2 , _BinaryPredicate ) ;

template < typename _RAIter >
void
nth_element ( _RAIter , _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
nth_element ( _RAIter , _RAIter , _RAIter , _Compare ) ;

template < typename _RAIter >
void
partial_sort ( _RAIter , _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
partial_sort ( _RAIter , _RAIter , _RAIter , _Compare ) ;

template < typename _BIter , typename _Predicate >
_BIter
partition ( _BIter , _BIter , _Predicate ) ;

template < typename _RAIter >
void
random_shuffle ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Generator >
void
random_shuffle ( _RAIter , _RAIter ,

_Generator && ) ;




template < typename _FIter , typename _Tp >
void
replace ( _FIter , _FIter , const _Tp & , const _Tp & ) ;

template < typename _FIter , typename _Predicate , typename _Tp >
void
replace_if ( _FIter , _FIter , _Predicate , const _Tp & ) ;

template < typename _FIter1 , typename _FIter2 >
_FIter1
search ( _FIter1 , _FIter1 , _FIter2 , _FIter2 ) ;

template < typename _FIter1 , typename _FIter2 , typename _BinaryPredicate >
_FIter1
search ( _FIter1 , _FIter1 , _FIter2 , _FIter2 , _BinaryPredicate ) ;

template < typename _FIter , typename _Size , typename _Tp >
_FIter
search_n ( _FIter , _FIter , _Size , const _Tp & ) ;

template < typename _FIter , typename _Size , typename _Tp ,
typename _BinaryPredicate >
_FIter
search_n ( _FIter , _FIter , _Size , const _Tp & , _BinaryPredicate ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter >
_OIter
set_difference ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter ,
typename _Compare >
_OIter
set_difference ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter , _Compare ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter >
_OIter
set_intersection ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter ,
typename _Compare >
_OIter
set_intersection ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter , _Compare ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter >
_OIter
set_symmetric_difference ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter ,
typename _Compare >
_OIter
set_symmetric_difference ( _IIter1 , _IIter1 , _IIter2 , _IIter2 ,
_OIter , _Compare ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter >
_OIter
set_union ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter ,
typename _Compare >
_OIter
set_union ( _IIter1 , _IIter1 , _IIter2 , _IIter2 , _OIter , _Compare ) ;

template < typename _RAIter >
void
sort ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
sort ( _RAIter , _RAIter , _Compare ) ;

template < typename _RAIter >
void
stable_sort ( _RAIter , _RAIter ) ;

template < typename _RAIter , typename _Compare >
void
stable_sort ( _RAIter , _RAIter , _Compare ) ;

template < typename _IIter , typename _OIter , typename _UnaryOperation >
_OIter
transform ( _IIter , _IIter , _OIter , _UnaryOperation ) ;

template < typename _IIter1 , typename _IIter2 , typename _OIter ,
typename _BinaryOperation >
_OIter
transform ( _IIter1 , _IIter1 , _IIter2 , _OIter , _BinaryOperation ) ;

template < typename _IIter , typename _OIter >
_OIter
unique_copy ( _IIter , _IIter , _OIter ) ;

template < typename _IIter , typename _OIter , typename _BinaryPredicate >
_OIter
unique_copy ( _IIter , _IIter , _OIter , _BinaryPredicate ) ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_heap.h"
#61
namespace std
{
#70
template < typename _RandomAccessIterator , typename _Distance >
_Distance
__is_heap_until ( _RandomAccessIterator __first , _Distance __n )
{
_Distance __parent = 0 ;
for ( _Distance __child = 1 ; __child < __n ; ++ __child )
{
if ( __first [ __parent ] < __first [ __child ] )
return __child ;
if ( ( __child & 1 ) == 0 )
++ __parent ;
}
return __n ;
}

template < typename _RandomAccessIterator , typename _Distance ,
typename _Compare >
_Distance
__is_heap_until ( _RandomAccessIterator __first , _Distance __n ,
_Compare __comp )
{
_Distance __parent = 0 ;
for ( _Distance __child = 1 ; __child < __n ; ++ __child )
{
if ( __comp ( __first [ __parent ] , __first [ __child ] ) )
return __child ;
if ( ( __child & 1 ) == 0 )
++ __parent ;
}
return __n ;
}



template < typename _RandomAccessIterator , typename _Distance >
inline bool
__is_heap ( _RandomAccessIterator __first , _Distance __n )
{ return std :: __is_heap_until ( __first , __n ) == __n ; }

template < typename _RandomAccessIterator , typename _Compare ,
typename _Distance >
inline bool
__is_heap ( _RandomAccessIterator __first , _Compare __comp , _Distance __n )
{ return std :: __is_heap_until ( __first , __n , __comp ) == __n ; }

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

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




template < typename _RandomAccessIterator , typename _Distance , typename _Tp >
void
__push_heap ( _RandomAccessIterator __first ,
_Distance __holeIndex , _Distance __topIndex , _Tp __value )
{
_Distance __parent = ( __holeIndex - 1 ) / 2 ;
while ( __holeIndex > __topIndex && * ( __first + __parent ) < __value )
{
* ( __first + __holeIndex ) = std :: move ( * ( __first + __parent ) ) ;
__holeIndex = __parent ;
__parent = ( __holeIndex - 1 ) / 2 ;
}
* ( __first + __holeIndex ) = std :: move ( __value ) ;
}
#154
template < typename _RandomAccessIterator >
inline void
push_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;





;
;

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

template < typename _RandomAccessIterator , typename _Distance , typename _Tp ,
typename _Compare >
void
__push_heap ( _RandomAccessIterator __first , _Distance __holeIndex ,
_Distance __topIndex , _Tp __value , _Compare __comp )
{
_Distance __parent = ( __holeIndex - 1 ) / 2 ;
while ( __holeIndex > __topIndex
&& __comp ( * ( __first + __parent ) , __value ) )
{
* ( __first + __holeIndex ) = std :: move ( * ( __first + __parent ) ) ;
__holeIndex = __parent ;
__parent = ( __holeIndex - 1 ) / 2 ;
}
* ( __first + __holeIndex ) = std :: move ( __value ) ;
}
#204
template < typename _RandomAccessIterator , typename _Compare >
inline void
push_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;




;
;

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

template < typename _RandomAccessIterator , typename _Distance , typename _Tp >
void
__adjust_heap ( _RandomAccessIterator __first , _Distance __holeIndex ,
_Distance __len , _Tp __value )
{
const _Distance __topIndex = __holeIndex ;
_Distance __secondChild = __holeIndex ;
while ( __secondChild < ( __len - 1 ) / 2 )
{
__secondChild = 2 * ( __secondChild + 1 ) ;
if ( * ( __first + __secondChild ) < * ( __first + ( __secondChild - 1 ) ) )
__secondChild -- ;
* ( __first + __holeIndex ) = std :: move ( * ( __first + __secondChild ) ) ;
__holeIndex = __secondChild ;
}
if ( ( __len & 1 ) == 0 && __secondChild == ( __len - 2 ) / 2 )
{
__secondChild = 2 * ( __secondChild + 1 ) ;
* ( __first + __holeIndex ) =
std :: move ( * ( __first + ( __secondChild - 1 ) ) ) ;
__holeIndex = __secondChild - 1 ;
}
std :: __push_heap ( __first , __holeIndex , __topIndex ,
std :: move ( __value ) ) ;
}

template < typename _RandomAccessIterator >
inline void
__pop_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_RandomAccessIterator __result )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;

_ValueType __value = std :: move ( * __result ) ;
* __result = std :: move ( * __first ) ;
std :: __adjust_heap ( __first , _DistanceType ( 0 ) ,
_DistanceType ( __last - __first ) ,
std :: move ( __value ) ) ;
}
#279
template < typename _RandomAccessIterator >
inline void
pop_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;





;
;
;

if ( __last - __first > 1 )
{
-- __last ;
std :: __pop_heap ( __first , __last , __last ) ;
}
}

template < typename _RandomAccessIterator , typename _Distance ,
typename _Tp , typename _Compare >
void
__adjust_heap ( _RandomAccessIterator __first , _Distance __holeIndex ,
_Distance __len , _Tp __value , _Compare __comp )
{
const _Distance __topIndex = __holeIndex ;
_Distance __secondChild = __holeIndex ;
while ( __secondChild < ( __len - 1 ) / 2 )
{
__secondChild = 2 * ( __secondChild + 1 ) ;
if ( __comp ( * ( __first + __secondChild ) ,
* ( __first + ( __secondChild - 1 ) ) ) )
__secondChild -- ;
* ( __first + __holeIndex ) = std :: move ( * ( __first + __secondChild ) ) ;
__holeIndex = __secondChild ;
}
if ( ( __len & 1 ) == 0 && __secondChild == ( __len - 2 ) / 2 )
{
__secondChild = 2 * ( __secondChild + 1 ) ;
* ( __first + __holeIndex ) =
std :: move ( * ( __first + ( __secondChild - 1 ) ) ) ;
__holeIndex = __secondChild - 1 ;
}
std :: __push_heap ( __first , __holeIndex , __topIndex ,
std :: move ( __value ) , __comp ) ;
}

template < typename _RandomAccessIterator , typename _Compare >
inline void
__pop_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_RandomAccessIterator __result , _Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;

_ValueType __value = std :: move ( * __result ) ;
* __result = std :: move ( * __first ) ;
std :: __adjust_heap ( __first , _DistanceType ( 0 ) ,
_DistanceType ( __last - __first ) ,
std :: move ( __value ) , __comp ) ;
}
#357
template < typename _RandomAccessIterator , typename _Compare >
inline void
pop_heap ( _RandomAccessIterator __first ,
_RandomAccessIterator __last , _Compare __comp )
{



;
;
;

if ( __last - __first > 1 )
{
-- __last ;
std :: __pop_heap ( __first , __last , __last , __comp ) ;
}
}
#384
template < typename _RandomAccessIterator >
void
make_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;





;

if ( __last - __first < 2 )
return ;

const _DistanceType __len = __last - __first ;
_DistanceType __parent = ( __len - 2 ) / 2 ;
while ( true )
{
_ValueType __value = std :: move ( * ( __first + __parent ) ) ;
std :: __adjust_heap ( __first , __parent , __len , std :: move ( __value ) ) ;
if ( __parent == 0 )
return ;
__parent -- ;
}
}
#424
template < typename _RandomAccessIterator , typename _Compare >
void
make_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;




;

if ( __last - __first < 2 )
return ;

const _DistanceType __len = __last - __first ;
_DistanceType __parent = ( __len - 2 ) / 2 ;
while ( true )
{
_ValueType __value = std :: move ( * ( __first + __parent ) ) ;
std :: __adjust_heap ( __first , __parent , __len , std :: move ( __value ) ,
__comp ) ;
if ( __parent == 0 )
return ;
__parent -- ;
}
}
#463
template < typename _RandomAccessIterator >
void
sort_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{





;
;

while ( __last - __first > 1 )
{
-- __last ;
std :: __pop_heap ( __first , __last , __last ) ;
}
}
#492
template < typename _RandomAccessIterator , typename _Compare >
void
sort_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Compare __comp )
{



;
;

while ( __last - __first > 1 )
{
-- __last ;
std :: __pop_heap ( __first , __last , __last , __comp ) ;
}
}
#521
template < typename _RandomAccessIterator >
inline _RandomAccessIterator
is_heap_until ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{





;

return __first + std :: __is_heap_until ( __first , std :: distance ( __first ,
__last ) ) ;
}
#547
template < typename _RandomAccessIterator , typename _Compare >
inline _RandomAccessIterator
is_heap_until ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Compare __comp )
{



;

return __first + std :: __is_heap_until ( __first , std :: distance ( __first ,
__last ) ,
__comp ) ;
}
#569
template < typename _RandomAccessIterator >
inline bool
is_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{ return std :: is_heap_until ( __first , __last ) == __last ; }
#582
template < typename _RandomAccessIterator , typename _Compare >
inline bool
is_heap ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Compare __comp )
{ return std :: is_heap_until ( __first , __last , __comp ) == __last ; }



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_tempbuf.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_construct.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/alloc_traits.h"
#32
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/alloc_traits.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/ptr_traits.h"
#37
namespace std
{


template < typename _Tp > class __has_element_type_helper : __sfinae_types { template < typename _Up > struct _Wrap_type
#41
{ } ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: element_type > * ) ; template < typename
#41
_Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) == 1 ; } ; template
#41
< typename _Tp > struct __has_element_type : integral_constant < bool , __has_element_type_helper < typename remove_cv <
#41
_Tp > :: type > :: value > { } ;
template < typename _Tp > class __has_difference_type_helper : __sfinae_types { template < typename _Up > struct _Wrap_type
#42
{ } ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: difference_type > * ) ; template < typename
#42
_Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) == 1 ; } ; template
#42
< typename _Tp > struct __has_difference_type : integral_constant < bool , __has_difference_type_helper < typename remove_cv
#42
< _Tp > :: type > :: value > { } ;

template < typename _Tp , bool = __has_element_type < _Tp > :: value >
struct __ptrtr_elt_type ;

template < typename _Tp >
struct __ptrtr_elt_type < _Tp , true >
{
typedef typename _Tp :: element_type __type ;
} ;

template < template < typename , typename ... > class _SomePtr , typename _Tp ,
typename ... _Args >
struct __ptrtr_elt_type < _SomePtr < _Tp , _Args ... > , false >
{
typedef _Tp __type ;
} ;

template < typename _Tp , bool = __has_difference_type < _Tp > :: value >
struct __ptrtr_diff_type
{
typedef typename _Tp :: difference_type __type ;
} ;

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

template < typename _Ptr , typename _Up >
class __ptrtr_rebind_helper
{
template < typename _Ptr2 , typename _Up2 >
static constexpr bool
_S_chk ( typename _Ptr2 :: template rebind < _Up2 > * )
{ return true ; }

template < typename , typename >
static constexpr bool
_S_chk ( ... )
{ return false ; }

public :
static const bool __value = _S_chk < _Ptr , _Up > ( nullptr ) ;
} ;

template < typename _Ptr , typename _Up >
const bool __ptrtr_rebind_helper < _Ptr , _Up > :: __value ;

template < typename _Tp , typename _Up ,
bool = __ptrtr_rebind_helper < _Tp , _Up > :: __value >
struct __ptrtr_rebind ;

template < typename _Tp , typename _Up >
struct __ptrtr_rebind < _Tp , _Up , true >
{
typedef typename _Tp :: template rebind < _Up > __type ;
} ;

template < template < typename , typename ... > class _SomePtr , typename _Up ,
typename _Tp , typename ... _Args >
struct __ptrtr_rebind < _SomePtr < _Tp , _Args ... > , _Up , false >
{
typedef _SomePtr < _Up , _Args ... > __type ;
} ;

template < typename _Tp , typename = typename remove_cv < _Tp > :: type >
struct __ptrtr_not_void
{
typedef _Tp __type ;
} ;

template < typename _Tp >
struct __ptrtr_not_void < _Tp , void >
{
struct __type { } ;
} ;

template < typename _Ptr >
class __ptrtr_pointer_to
{
typedef typename __ptrtr_elt_type < _Ptr > :: __type __orig_type ;
typedef typename __ptrtr_not_void < __orig_type > :: __type __element_type ;

public :
static _Ptr pointer_to ( __element_type & __e )
{ return _Ptr :: pointer_to ( __e ) ; }
} ;





template < typename _Ptr >
struct pointer_traits : __ptrtr_pointer_to < _Ptr >
{

typedef _Ptr pointer ;

typedef typename __ptrtr_elt_type < _Ptr > :: __type element_type ;

typedef typename __ptrtr_diff_type < _Ptr > :: __type difference_type ;

template < typename _Up >
using rebind = typename __ptrtr_rebind < _Ptr , _Up > :: __type ;
} ;





template < typename _Tp >
struct pointer_traits < _Tp * >
{

typedef _Tp * pointer ;

typedef _Tp element_type ;

typedef ptrdiff_t difference_type ;

template < typename _Up >
using rebind = _Up * ;
#172
static pointer
pointer_to ( typename __ptrtr_not_void < element_type > :: __type & __r ) noexcept
{ return std :: addressof ( __r ) ; }
} ;


}
#39 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/alloc_traits.h"
namespace std
{


template < typename _Alloc , typename _Tp >
class __alloctr_rebind_helper
{
template < typename _Alloc2 , typename _Tp2 >
static constexpr bool
_S_chk ( typename _Alloc2 :: template rebind < _Tp2 > :: other * )
{ return true ; }

template < typename , typename >
static constexpr bool
_S_chk ( ... )
{ return false ; }

public :
static const bool __value = _S_chk < _Alloc , _Tp > ( nullptr ) ;
} ;

template < typename _Alloc , typename _Tp >
const bool __alloctr_rebind_helper < _Alloc , _Tp > :: __value ;

template < typename _Alloc , typename _Tp ,
bool = __alloctr_rebind_helper < _Alloc , _Tp > :: __value >
struct __alloctr_rebind ;

template < typename _Alloc , typename _Tp >
struct __alloctr_rebind < _Alloc , _Tp , true >
{
typedef typename _Alloc :: template rebind < _Tp > :: other __type ;
} ;

template < template < typename , typename ... > class _Alloc , typename _Tp ,
typename _Up , typename ... _Args >
struct __alloctr_rebind < _Alloc < _Up , _Args ... > , _Tp , false >
{
typedef _Alloc < _Tp , _Args ... > __type ;
} ;





template < typename _Alloc >
struct allocator_traits
{

typedef _Alloc allocator_type ;

typedef typename _Alloc :: value_type value_type ;
#100
private : template < typename _Tp > static typename _Tp :: pointer _S_pointer_helper ( _Tp * ) ; static value_type * _S_pointer_helper
#100
( ... ) ; typedef decltype ( _S_pointer_helper ( ( _Alloc * ) 0 ) ) __pointer ; public :
#107
typedef __pointer pointer ;


private : template < typename _Tp > static typename _Tp :: const_pointer _S_const_pointer_helper ( _Tp * ) ; static typename
#110
pointer_traits < pointer > :: template rebind < const value_type > _S_const_pointer_helper ( ... ) ; typedef decltype ( _S_const_pointer_helper
#110
( ( _Alloc * ) 0 ) ) __const_pointer ; public :
#118
typedef __const_pointer const_pointer ;


private : template < typename _Tp > static typename _Tp :: void_pointer _S_void_pointer_helper ( _Tp * ) ; static typename
#121
pointer_traits < pointer > :: template rebind < void > _S_void_pointer_helper ( ... ) ; typedef decltype ( _S_void_pointer_helper
#121
( ( _Alloc * ) 0 ) ) __void_pointer ; public :
#129
typedef __void_pointer void_pointer ;


private : template < typename _Tp > static typename _Tp :: const_void_pointer _S_const_void_pointer_helper ( _Tp * ) ; static
#132
typename pointer_traits < pointer > :: template rebind < const void > _S_const_void_pointer_helper ( ... ) ; typedef decltype
#132
( _S_const_void_pointer_helper ( ( _Alloc * ) 0 ) ) __const_void_pointer ; public :
#140
typedef __const_void_pointer const_void_pointer ;


private : template < typename _Tp > static typename _Tp :: difference_type _S_difference_type_helper ( _Tp * ) ; static typename
#143
pointer_traits < pointer > :: difference_type _S_difference_type_helper ( ... ) ; typedef decltype ( _S_difference_type_helper
#143
( ( _Alloc * ) 0 ) ) __difference_type ; public :
#151
typedef __difference_type difference_type ;


private : template < typename _Tp > static typename _Tp :: size_type _S_size_type_helper ( _Tp * ) ; static typename make_unsigned
#154
< difference_type > :: type _S_size_type_helper ( ... ) ; typedef decltype ( _S_size_type_helper ( ( _Alloc * ) 0 ) ) __size_type
#154
; public :
#162
typedef __size_type size_type ;


private : template < typename _Tp > static typename _Tp :: propagate_on_container_copy_assignment _S_propagate_on_container_copy_assignment_helper
#165
( _Tp * ) ; static false_type _S_propagate_on_container_copy_assignment_helper ( ... ) ; typedef decltype ( _S_propagate_on_container_copy_assignment_helper
#165
( ( _Alloc * ) 0 ) ) __propagate_on_container_copy_assignment ; public :
#173
typedef __propagate_on_container_copy_assignment
propagate_on_container_copy_assignment ;


private : template < typename _Tp > static typename _Tp :: propagate_on_container_move_assignment _S_propagate_on_container_move_assignment_helper
#177
( _Tp * ) ; static false_type _S_propagate_on_container_move_assignment_helper ( ... ) ; typedef decltype ( _S_propagate_on_container_move_assignment_helper
#177
( ( _Alloc * ) 0 ) ) __propagate_on_container_move_assignment ; public :
#185
typedef __propagate_on_container_move_assignment
propagate_on_container_move_assignment ;


private : template < typename _Tp > static typename _Tp :: propagate_on_container_swap _S_propagate_on_container_swap_helper
#189
( _Tp * ) ; static false_type _S_propagate_on_container_swap_helper ( ... ) ; typedef decltype ( _S_propagate_on_container_swap_helper
#189
( ( _Alloc * ) 0 ) ) __propagate_on_container_swap ; public :
#197
typedef __propagate_on_container_swap propagate_on_container_swap ;



template < typename _Tp >
using rebind_alloc = typename __alloctr_rebind < _Alloc , _Tp > :: __type ;
template < typename _Tp >
using rebind_traits = allocator_traits < rebind_alloc < _Tp >> ;

private :
template < typename _Alloc2 >
struct __allocate_helper
{
template < typename _Alloc3 ,
typename = decltype ( std :: declval < _Alloc3 * > ( ) -> allocate (
std :: declval < size_type > ( ) ,
std :: declval < const_void_pointer > ( ) ) ) >
static true_type __test ( int ) ;

template < typename >
static false_type __test ( ... ) ;

typedef decltype ( __test < _Alloc > ( 0 ) ) type ;
static const bool value = type :: value ;
} ;

template < typename _Alloc2 >
static typename
enable_if < __allocate_helper < _Alloc2 > :: value , pointer > :: type
_S_allocate ( _Alloc2 & __a , size_type __n , const_void_pointer __hint )
{ return __a . allocate ( __n , __hint ) ; }

template < typename _Alloc2 >
static typename
enable_if < ! __allocate_helper < _Alloc2 > :: value , pointer > :: type
_S_allocate ( _Alloc2 & __a , size_type __n , ... )
{ return __a . allocate ( __n ) ; }

template < typename _Tp , typename ... _Args >
struct __construct_helper
{
template < typename _Alloc2 ,
typename = decltype ( std :: declval < _Alloc2 * > ( ) -> construct (
std :: declval < _Tp * > ( ) , std :: declval < _Args > ( ) ... ) ) >
static true_type __test ( int ) ;

template < typename >
static false_type __test ( ... ) ;

typedef decltype ( __test < _Alloc > ( 0 ) ) type ;
static const bool value = type :: value ;
} ;

template < typename _Tp , typename ... _Args >
static typename
enable_if < __construct_helper < _Tp , _Args ... > :: value , void > :: type
_S_construct ( _Alloc & __a , _Tp * __p , _Args && ... __args )
{ __a . construct ( __p , std :: forward < _Args > ( __args ) ... ) ; }

template < typename _Tp , typename ... _Args >
static typename
enable_if < __and_ < __not_ < __construct_helper < _Tp , _Args ... >> ,
is_constructible < _Tp , _Args ... >> :: value , void > :: type
_S_construct ( _Alloc & , _Tp * __p , _Args && ... __args )
{ :: new ( ( void * ) __p ) _Tp ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename _Tp >
struct __destroy_helper
{
template < typename _Alloc2 ,
typename = decltype ( std :: declval < _Alloc2 * > ( ) -> destroy (
std :: declval < _Tp * > ( ) ) ) >
static true_type __test ( int ) ;

template < typename >
static false_type __test ( ... ) ;

typedef decltype ( __test < _Alloc > ( 0 ) ) type ;
static const bool value = type :: value ;
} ;

template < typename _Tp >
static typename enable_if < __destroy_helper < _Tp > :: value , void > :: type
_S_destroy ( _Alloc & __a , _Tp * __p )
{ __a . destroy ( __p ) ; }

template < typename _Tp >
static typename enable_if < ! __destroy_helper < _Tp > :: value , void > :: type
_S_destroy ( _Alloc & , _Tp * __p )
{ __p -> ~ _Tp ( ) ; }

template < typename _Alloc2 >
struct __maxsize_helper
{
template < typename _Alloc3 ,
typename = decltype ( std :: declval < _Alloc3 * > ( ) -> max_size ( ) ) >
static true_type __test ( int ) ;

template < typename >
static false_type __test ( ... ) ;

typedef decltype ( __test < _Alloc2 > ( 0 ) ) type ;
static const bool value = type :: value ;
} ;

template < typename _Alloc2 >
static typename
enable_if < __maxsize_helper < _Alloc2 > :: value , size_type > :: type
_S_max_size ( _Alloc2 & __a )
{ return __a . max_size ( ) ; }

template < typename _Alloc2 >
static typename
enable_if < ! __maxsize_helper < _Alloc2 > :: value , size_type > :: type
_S_max_size ( _Alloc2 & )
{ return __gnu_cxx :: __numeric_traits < size_type > :: __max ; }

template < typename _Alloc2 >
struct __select_helper
{
template < typename _Alloc3 , typename
= decltype ( std :: declval < _Alloc3 * > ( )
-> select_on_container_copy_construction ( ) ) >
static true_type __test ( int ) ;

template < typename >
static false_type __test ( ... ) ;

typedef decltype ( __test < _Alloc2 > ( 0 ) ) type ;
static const bool value = type :: value ;
} ;
template < typename _Alloc2 >
static typename
enable_if < __select_helper < _Alloc2 > :: value , _Alloc2 > :: type
_S_select ( _Alloc2 & __a )
{ return __a . select_on_container_copy_construction ( ) ; }

template < typename _Alloc2 >
static typename
enable_if < ! __select_helper < _Alloc2 > :: value , _Alloc2 > :: type
_S_select ( _Alloc2 & __a )
{ return __a ; }

public :
#349
static pointer
allocate ( _Alloc & __a , size_type __n )
{ return __a . allocate ( __n ) ; }
#364
static pointer
allocate ( _Alloc & __a , size_type __n , const_void_pointer __hint )
{ return _S_allocate ( __a , __n , __hint ) ; }
#376
static void deallocate ( _Alloc & __a , pointer __p , size_type __n )
{ __a . deallocate ( __p , __n ) ; }
#390
template < typename _Tp , typename ... _Args >
static auto construct ( _Alloc & __a , _Tp * __p , _Args && ... __args )
-> decltype ( _S_construct ( __a , __p , std :: forward < _Args > ( __args ) ... ) )
{ _S_construct ( __a , __p , std :: forward < _Args > ( __args ) ... ) ; }
#403
template < class _Tp >
static void destroy ( _Alloc & __a , _Tp * __p )
{ _S_destroy ( __a , __p ) ; }
#415
static size_type max_size ( const _Alloc & __a )
{ return _S_max_size ( __a ) ; }
#426
static _Alloc
select_on_container_copy_construction ( const _Alloc & __rhs )
{ return _S_select ( __rhs ) ; }
} ;

template < typename _Alloc >
template < typename _Alloc2 >
const bool allocator_traits < _Alloc > :: __allocate_helper < _Alloc2 > :: value ;

template < typename _Alloc >
template < typename _Tp , typename ... _Args >
const bool
allocator_traits < _Alloc > :: __construct_helper < _Tp , _Args ... > :: value ;

template < typename _Alloc >
template < typename _Tp >
const bool allocator_traits < _Alloc > :: __destroy_helper < _Tp > :: value ;

template < typename _Alloc >
template < typename _Alloc2 >
const bool allocator_traits < _Alloc > :: __maxsize_helper < _Alloc2 > :: value ;

template < typename _Alloc >
template < typename _Alloc2 >
const bool allocator_traits < _Alloc > :: __select_helper < _Alloc2 > :: value ;

template < typename _Alloc >
inline void
__do_alloc_on_copy ( _Alloc & __one , const _Alloc & __two , true_type )
{ __one = __two ; }

template < typename _Alloc >
inline void
__do_alloc_on_copy ( _Alloc & , const _Alloc & , false_type )
{ }

template < typename _Alloc >
inline void __alloc_on_copy ( _Alloc & __one , const _Alloc & __two )
{
typedef allocator_traits < _Alloc > __traits ;
typedef typename __traits :: propagate_on_container_copy_assignment __pocca ;
__do_alloc_on_copy ( __one , __two , __pocca ( ) ) ;
}

template < typename _Alloc >
inline _Alloc __alloc_on_copy ( const _Alloc & __a )
{
typedef allocator_traits < _Alloc > __traits ;
return __traits :: select_on_container_copy_construction ( __a ) ;
}

template < typename _Alloc >
inline void __do_alloc_on_move ( _Alloc & __one , _Alloc & __two , true_type )
{ __one = std :: move ( __two ) ; }

template < typename _Alloc >
inline void __do_alloc_on_move ( _Alloc & , _Alloc & , false_type )
{ }

template < typename _Alloc >
inline void __alloc_on_move ( _Alloc & __one , _Alloc & __two )
{
typedef allocator_traits < _Alloc > __traits ;
typedef typename __traits :: propagate_on_container_move_assignment __pocma ;
__do_alloc_on_move ( __one , __two , __pocma ( ) ) ;
}

template < typename _Alloc >
inline void __do_alloc_on_swap ( _Alloc & __one , _Alloc & __two , true_type )
{
using std :: swap ;
swap ( __one , __two ) ;
}

template < typename _Alloc >
inline void __do_alloc_on_swap ( _Alloc & , _Alloc & , false_type )
{ }

template < typename _Alloc >
inline void __alloc_on_swap ( _Alloc & __one , _Alloc & __two )
{
typedef allocator_traits < _Alloc > __traits ;
typedef typename __traits :: propagate_on_container_swap __pocs ;
__do_alloc_on_swap ( __one , __two , __pocs ( ) ) ;
}

template < typename _Alloc >
class __is_copy_insertable_impl
{
typedef allocator_traits < _Alloc > _Traits ;

template < typename _Up , typename
= decltype ( _Traits :: construct ( std :: declval < _Alloc & > ( ) ,
std :: declval < _Up * > ( ) ,
std :: declval < const _Up & > ( ) ) ) >
static true_type
_M_select ( int ) ;

template < typename _Up >
static false_type
_M_select ( ... ) ;

public :
typedef decltype ( _M_select < typename _Alloc :: value_type > ( 0 ) ) type ;
} ;


template < typename _Alloc >
struct __is_copy_insertable
: __is_copy_insertable_impl < _Alloc > :: type
{ } ;


template < typename _Tp >
struct __is_copy_insertable < allocator < _Tp >>
: is_copy_constructible < _Tp >
{ } ;


template < bool > struct __allow_copy_cons { } ;


template < >
struct __allow_copy_cons < false >
{
__allow_copy_cons ( ) = default ;
__allow_copy_cons ( const __allow_copy_cons & ) = delete ;
__allow_copy_cons ( __allow_copy_cons && ) = default ;
__allow_copy_cons & operator = ( const __allow_copy_cons & ) = default ;
__allow_copy_cons & operator = ( __allow_copy_cons && ) = default ;
} ;

template < typename _Alloc >
using __check_copy_constructible
= __allow_copy_cons < __is_copy_insertable < _Alloc > :: value > ;


}
#41 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/alloc_traits.h"
namespace __gnu_cxx
{



template < typename _Alloc >
struct __allocator_always_compares_equal
{ static const bool value = false ; } ;

template < typename _Alloc >
const bool __allocator_always_compares_equal < _Alloc > :: value ;

template < typename _Tp >
struct __allocator_always_compares_equal < std :: allocator < _Tp >>
{ static const bool value = true ; } ;

template < typename _Tp >
const bool __allocator_always_compares_equal < std :: allocator < _Tp >> :: value ;

template < typename , typename > struct array_allocator ;

template < typename _Tp , typename _Array >
struct __allocator_always_compares_equal < array_allocator < _Tp , _Array >>
{ static const bool value = true ; } ;

template < typename _Tp , typename _Array >
const bool
__allocator_always_compares_equal < array_allocator < _Tp , _Array >> :: value ;

template < typename > struct bitmap_allocator ;

template < typename _Tp >
struct __allocator_always_compares_equal < bitmap_allocator < _Tp >>
{ static const bool value = true ; } ;

template < typename _Tp >
const bool __allocator_always_compares_equal < bitmap_allocator < _Tp >> :: value ;

template < typename > struct malloc_allocator ;

template < typename _Tp >
struct __allocator_always_compares_equal < malloc_allocator < _Tp >>
{ static const bool value = true ; } ;

template < typename _Tp >
const bool __allocator_always_compares_equal < malloc_allocator < _Tp >> :: value ;

template < typename > struct mt_allocator ;

template < typename _Tp >
struct __allocator_always_compares_equal < mt_allocator < _Tp >>
{ static const bool value = true ; } ;

template < typename _Tp >
const bool __allocator_always_compares_equal < mt_allocator < _Tp >> :: value ;

template < typename > struct new_allocator ;

template < typename _Tp >
struct __allocator_always_compares_equal < new_allocator < _Tp >>
{ static const bool value = true ; } ;

template < typename _Tp >
const bool __allocator_always_compares_equal < new_allocator < _Tp >> :: value ;

template < typename > struct pool_allocator ;

template < typename _Tp >
struct __allocator_always_compares_equal < pool_allocator < _Tp >>
{ static const bool value = true ; } ;

template < typename _Tp >
const bool __allocator_always_compares_equal < pool_allocator < _Tp >> :: value ;
#120
template < typename _Alloc >
struct __alloc_traits

: std :: allocator_traits < _Alloc >

{
typedef _Alloc allocator_type ;

typedef std :: allocator_traits < _Alloc > _Base_type ;
typedef typename _Base_type :: value_type value_type ;
typedef typename _Base_type :: pointer pointer ;
typedef typename _Base_type :: const_pointer const_pointer ;
typedef typename _Base_type :: size_type size_type ;
typedef typename _Base_type :: difference_type difference_type ;

typedef value_type & reference ;
typedef const value_type & const_reference ;
using _Base_type :: allocate ;
using _Base_type :: deallocate ;
using _Base_type :: construct ;
using _Base_type :: destroy ;
using _Base_type :: max_size ;

private :
template < typename _Ptr >
struct __is_custom_pointer
: std :: integral_constant < bool , std :: is_same < pointer , _Ptr > :: value
&& ! std :: is_pointer < _Ptr > :: value >
{ } ;

public :

template < typename _Ptr , typename ... _Args >
static typename std :: enable_if < __is_custom_pointer < _Ptr > :: value > :: type
construct ( _Alloc & __a , _Ptr __p , _Args && ... __args )
{
_Base_type :: construct ( __a , std :: addressof ( * __p ) ,
std :: forward < _Args > ( __args ) ... ) ;
}


template < typename _Ptr >
static typename std :: enable_if < __is_custom_pointer < _Ptr > :: value > :: type
destroy ( _Alloc & __a , _Ptr __p )
{ _Base_type :: destroy ( __a , std :: addressof ( * __p ) ) ; }

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

static void _S_on_swap ( _Alloc & __a , _Alloc & __b )
{ std :: __alloc_on_swap ( __a , __b ) ; }

static constexpr bool _S_propagate_on_copy_assign ( )
{ return _Base_type :: propagate_on_container_copy_assignment :: value ; }

static constexpr bool _S_propagate_on_move_assign ( )
{ return _Base_type :: propagate_on_container_move_assignment :: value ; }

static constexpr bool _S_propagate_on_swap ( )
{ return _Base_type :: propagate_on_container_swap :: value ; }

static constexpr bool _S_always_equal ( )
{ return __allocator_always_compares_equal < _Alloc > :: value ; }

static constexpr bool _S_nothrow_move ( )
{ return _S_propagate_on_move_assign ( ) || _S_always_equal ( ) ; }

static constexpr bool _S_nothrow_swap ( )
{
using std :: swap ;
return ! _S_propagate_on_swap ( )
|| noexcept ( swap ( std :: declval < _Alloc & > ( ) , std :: declval < _Alloc & > ( ) ) ) ;
}

template < typename _Tp >
struct rebind
{ typedef typename _Base_type :: template rebind_alloc < _Tp > other ; } ;
#237
} ;


}
#63 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_construct.h"
namespace std
{
#72
template < typename _T1 , typename ... _Args >
inline void
_Construct ( _T1 * __p , _Args && ... __args )
{ :: new ( static_cast < void * > ( __p ) ) _T1 ( std :: forward < _Args > ( __args ) ... ) ; }
#90
template < typename _Tp >
inline void
_Destroy ( _Tp * __pointer )
{ __pointer -> ~ _Tp ( ) ; }

template < bool >
struct _Destroy_aux
{
template < typename _ForwardIterator >
static void
__destroy ( _ForwardIterator __first , _ForwardIterator __last )
{
for ( ; __first != __last ; ++ __first )
std :: _Destroy ( std :: __addressof ( * __first ) ) ;
}
} ;

template < >
struct _Destroy_aux < true >
{
template < typename _ForwardIterator >
static void
__destroy ( _ForwardIterator , _ForwardIterator ) { }
} ;
#120
template < typename _ForwardIterator >
inline void
_Destroy ( _ForwardIterator __first , _ForwardIterator __last )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_Value_type ;
std :: _Destroy_aux < __oracle_has_trivial_destructor ( _Value_type ) > ::
__destroy ( __first , __last ) ;
}
#136
template < typename _ForwardIterator , typename _Allocator >
void
_Destroy ( _ForwardIterator __first , _ForwardIterator __last ,
_Allocator & __alloc )
{
typedef __gnu_cxx :: __alloc_traits < _Allocator > __traits ;
for ( ; __first != __last ; ++ __first )
__traits :: destroy ( __alloc , std :: __addressof ( * __first ) ) ;
}

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


}
#62 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_tempbuf.h"
namespace std
{
#83
template < typename _Tp >
pair < _Tp * , ptrdiff_t >
get_temporary_buffer ( ptrdiff_t __len ) noexcept
{
const ptrdiff_t __max =
__gnu_cxx :: __numeric_traits < ptrdiff_t > :: __max / sizeof ( _Tp ) ;
if ( __len > __max )
__len = __max ;

while ( __len > 0 )
{
_Tp * __tmp = static_cast < _Tp * > ( :: operator new ( __len * sizeof ( _Tp ) ,
std :: nothrow ) ) ;
if ( __tmp != 0 )
return std :: pair < _Tp * , ptrdiff_t > ( __tmp , __len ) ;
__len /= 2 ;
}
return std :: pair < _Tp * , ptrdiff_t > ( static_cast < _Tp * > ( 0 ) , 0 ) ;
}
#110
template < typename _Tp >
inline void
return_temporary_buffer ( _Tp * __p )
{ :: operator delete ( __p , std :: nothrow ) ; }
#121
template < typename _ForwardIterator , typename _Tp >
class _Temporary_buffer
{



public :
typedef _Tp value_type ;
typedef value_type * pointer ;
typedef pointer iterator ;
typedef ptrdiff_t size_type ;

protected :
size_type _M_original_len ;
size_type _M_len ;
pointer _M_buffer ;

public :

size_type
size ( ) const
{ return _M_len ; }


size_type
requested_size ( ) const
{ return _M_original_len ; }


iterator
begin ( )
{ return _M_buffer ; }


iterator
end ( )
{ return _M_buffer + _M_len ; }





_Temporary_buffer ( _ForwardIterator __first , _ForwardIterator __last ) ;

~ _Temporary_buffer ( )
{
std :: _Destroy ( _M_buffer , _M_buffer + _M_len ) ;
std :: return_temporary_buffer ( _M_buffer ) ;
}

private :

_Temporary_buffer ( const _Temporary_buffer & ) ;

void
operator = ( const _Temporary_buffer & ) ;
} ;


template < bool >
struct __uninitialized_construct_buf_dispatch
{
template < typename _Pointer , typename _ForwardIterator >
static void
__ucr ( _Pointer __first , _Pointer __last ,
_ForwardIterator __seed )
{
if ( __first == __last )
return ;

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

template < >
struct __uninitialized_construct_buf_dispatch < true >
{
template < typename _Pointer , typename _ForwardIterator >
static void
__ucr ( _Pointer , _Pointer , _ForwardIterator ) { }
} ;
#229
template < typename _Pointer , typename _ForwardIterator >
inline void
__uninitialized_construct_buf ( _Pointer __first , _Pointer __last ,
_ForwardIterator __seed )
{
typedef typename std :: iterator_traits < _Pointer > :: value_type
_ValueType ;

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

template < typename _ForwardIterator , typename _Tp >
_Temporary_buffer < _ForwardIterator , _Tp > ::
_Temporary_buffer ( _ForwardIterator __first , _ForwardIterator __last )
: _M_original_len ( std :: distance ( __first , __last ) ) ,
_M_len ( 0 ) , _M_buffer ( 0 )
{
try
{
std :: pair < pointer , size_type > __p ( std :: get_temporary_buffer <
value_type > ( _M_original_len ) ) ;
_M_buffer = __p . first ;
_M_len = __p . second ;
if ( _M_buffer )
std :: __uninitialized_construct_buf ( _M_buffer , _M_buffer + _M_len ,
__first ) ;
}
catch ( ... )
{
std :: return_temporary_buffer ( _M_buffer ) ;
_M_buffer = 0 ;
_M_len = 0 ;
throw ;
}
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/random"
#32
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cmath"
#39
#pragma GCC system_header
#1 "/usr/include/math.h"
#9
#pragma ident "@(#)math.h   2.25    09/05/19 SMI"
#1 "/usr/include/iso/math_iso.h"
#9
#pragma ident "@(#)math_iso.h   1.9 04/10/23 SMI"
#14
extern "C" {
#26
typedef union _h_val {
unsigned long _i [ sizeof ( double ) / sizeof ( unsigned long ) ] ;
double _d ;
} _h_val ;


extern const _h_val __huge_val ;
#41
namespace std {


extern double acos ( double ) ;
extern double asin ( double ) ;
extern double atan ( double ) ;
extern double atan2 ( double , double ) ;
extern double cos ( double ) ;
extern double sin ( double ) ;
extern double tan ( double ) ;

extern double cosh ( double ) ;
extern double sinh ( double ) ;
extern double tanh ( double ) ;

extern double exp ( double ) ;
extern double frexp ( double , int * ) ;
extern double ldexp ( double , int ) ;
extern double log ( double ) ;
extern double log10 ( double ) ;
extern double modf ( double , double * ) ;

extern double pow ( double , double ) ;
extern double sqrt ( double ) ;

extern double ceil ( double ) ;
extern double fabs ( double ) ;
extern double floor ( double ) ;
extern double fmod ( double , double ) ;
#90
extern float __acosf ( float ) ;
extern float __asinf ( float ) ;
extern float __atanf ( float ) ;
extern float __atan2f ( float , float ) ;
extern float __ceilf ( float ) ;
extern float __cosf ( float ) ;
extern float __coshf ( float ) ;
extern float __expf ( float ) ;
extern float __fabsf ( float ) ;
extern float __floorf ( float ) ;
extern float __fmodf ( float , float ) ;
extern float __frexpf ( float , int * ) ;
extern float __ldexpf ( float , int ) ;
extern float __logf ( float ) ;
extern float __log10f ( float ) ;
extern float __modff ( float , float * ) ;
extern float __powf ( float , float ) ;
extern float __sinf ( float ) ;
extern float __sinhf ( float ) ;
extern float __sqrtf ( float ) ;
extern float __tanf ( float ) ;
extern float __tanhf ( float ) ;

extern long double __acosl ( long double ) ;
extern long double __asinl ( long double ) ;
extern long double __atanl ( long double ) ;
extern long double __atan2l ( long double , long double ) ;
extern long double __ceill ( long double ) ;
extern long double __cosl ( long double ) ;
extern long double __coshl ( long double ) ;
extern long double __expl ( long double ) ;
extern long double __fabsl ( long double ) ;
extern long double __floorl ( long double ) ;
extern long double __fmodl ( long double , long double ) ;
extern long double __frexpl ( long double , int * ) ;
extern long double __ldexpl ( long double , int ) ;
extern long double __logl ( long double ) ;
extern long double __log10l ( long double ) ;
extern long double __modfl ( long double , long double * ) ;
extern long double __powl ( long double , long double ) ;
extern long double __sinl ( long double ) ;
extern long double __sinhl ( long double ) ;
extern long double __sqrtl ( long double ) ;
extern long double __tanl ( long double ) ;
extern long double __tanhl ( long double ) ;

extern "C++" {


inline double abs ( double __X ) { return fabs ( __X ) ; }
inline double pow ( double __X , int __Y ) { return
pow ( __X , ( double ) ( __Y ) ) ; }

inline float abs ( float __X ) { return __fabsf ( __X ) ; }
inline float acos ( float __X ) { return __acosf ( __X ) ; }
inline float asin ( float __X ) { return __asinf ( __X ) ; }
inline float atan ( float __X ) { return __atanf ( __X ) ; }
inline float atan2 ( float __X , float __Y ) { return __atan2f ( __X , __Y ) ; }
inline float ceil ( float __X ) { return __ceilf ( __X ) ; }
inline float cos ( float __X ) { return __cosf ( __X ) ; }
inline float cosh ( float __X ) { return __coshf ( __X ) ; }
inline float exp ( float __X ) { return __expf ( __X ) ; }
inline float fabs ( float __X ) { return __fabsf ( __X ) ; }
inline float floor ( float __X ) { return __floorf ( __X ) ; }
inline float fmod ( float __X , float __Y ) { return __fmodf ( __X , __Y ) ; }
inline float frexp ( float __X , int * __Y ) { return __frexpf ( __X , __Y ) ; }
inline float ldexp ( float __X , int __Y ) { return __ldexpf ( __X , __Y ) ; }
inline float log ( float __X ) { return __logf ( __X ) ; }
inline float log10 ( float __X ) { return __log10f ( __X ) ; }
inline float modf ( float __X , float * __Y ) { return __modff ( __X , __Y ) ; }
inline float pow ( float __X , float __Y ) { return __powf ( __X , __Y ) ; }
inline float pow ( float __X , int __Y ) { return
pow ( ( double ) ( __X ) , ( double ) ( __Y ) ) ; }
inline float sin ( float __X ) { return __sinf ( __X ) ; }
inline float sinh ( float __X ) { return __sinhf ( __X ) ; }
inline float sqrt ( float __X ) { return __sqrtf ( __X ) ; }
inline float tan ( float __X ) { return __tanf ( __X ) ; }
inline float tanh ( float __X ) { return __tanhf ( __X ) ; }

inline long double abs ( long double __X ) { return __fabsl ( __X ) ; }
inline long double acos ( long double __X ) { return __acosl ( __X ) ; }
inline long double asin ( long double __X ) { return __asinl ( __X ) ; }
inline long double atan ( long double __X ) { return __atanl ( __X ) ; }
inline long double atan2 ( long double __X , long double __Y ) { return
__atan2l ( __X , __Y ) ; }
inline long double ceil ( long double __X ) { return __ceill ( __X ) ; }
inline long double cos ( long double __X ) { return __cosl ( __X ) ; }
inline long double cosh ( long double __X ) { return __coshl ( __X ) ; }
inline long double exp ( long double __X ) { return __expl ( __X ) ; }
inline long double fabs ( long double __X ) { return __fabsl ( __X ) ; }
inline long double floor ( long double __X ) { return __floorl ( __X ) ; }
inline long double fmod ( long double __X , long double __Y ) { return
__fmodl ( __X , __Y ) ; }
inline long double frexp ( long double __X , int * __Y ) { return
__frexpl ( __X , __Y ) ; }
inline long double ldexp ( long double __X , int __Y ) { return
__ldexpl ( __X , __Y ) ; }
inline long double log ( long double __X ) { return __logl ( __X ) ; }
inline long double log10 ( long double __X ) { return __log10l ( __X ) ; }
inline long double modf ( long double __X , long double * __Y ) { return
__modfl ( __X , __Y ) ; }
inline long double pow ( long double __X , long double __Y ) { return
__powl ( __X , __Y ) ; }
inline long double pow ( long double __X , int __Y ) { return
__powl ( __X , ( long double ) ( __Y ) ) ; }
inline long double sin ( long double __X ) { return __sinl ( __X ) ; }
inline long double sinh ( long double __X ) { return __sinhl ( __X ) ; }
inline long double sqrt ( long double __X ) { return __sqrtl ( __X ) ; }
inline long double tan ( long double __X ) { return __tanl ( __X ) ; }
inline long double tanh ( long double __X ) { return __tanhl ( __X ) ; }
}



}



}
#1 "/usr/include/iso/math_c99.h"
#9
#pragma ident "@(#)math_c99.h   1.10    09/05/19 SMI"
#14
extern "C" {
#154
typedef float float_t ;
typedef double double_t ;
#206
extern double acosh ( double ) ;
extern double asinh ( double ) ;
extern double atanh ( double ) ;

extern double exp2 ( double ) ;
extern double expm1 ( double ) ;
extern int ilogb ( double ) ;
extern double log1p ( double ) ;
extern double log2 ( double ) ;
extern double logb ( double ) ;
extern double scalbn ( double , int ) ;
extern double scalbln ( double , long int ) ;

extern double cbrt ( double ) ;
extern double hypot ( double , double ) ;

extern double erf ( double ) ;
extern double erfc ( double ) ;
extern double lgamma ( double ) ;
extern double tgamma ( double ) ;

extern double nearbyint ( double ) ;
extern double rint ( double ) ;
extern long int lrint ( double ) ;
extern double round ( double ) ;
extern long int lround ( double ) ;
extern double trunc ( double ) ;

extern double remainder ( double , double ) ;
extern double remquo ( double , double , int * ) ;

extern double copysign ( double , double ) ;
extern double nan ( const char * ) ;
extern double nextafter ( double , double ) ;
extern double nexttoward ( double , long double ) ;

extern double fdim ( double , double ) ;
extern double fmax ( double , double ) ;
extern double fmin ( double , double ) ;

extern double fma ( double , double , double ) ;

extern float acosf ( float ) ;
extern float asinf ( float ) ;
extern float atanf ( float ) ;
extern float atan2f ( float , float ) ;
extern float cosf ( float ) ;
extern float sinf ( float ) ;
extern float tanf ( float ) ;

extern float acoshf ( float ) ;
extern float asinhf ( float ) ;
extern float atanhf ( float ) ;
extern float coshf ( float ) ;
extern float sinhf ( float ) ;
extern float tanhf ( float ) ;

extern float expf ( float ) ;
extern float exp2f ( float ) ;
extern float expm1f ( float ) ;
extern float frexpf ( float , int * ) ;
extern int ilogbf ( float ) ;
extern float ldexpf ( float , int ) ;
extern float logf ( float ) ;
extern float log10f ( float ) ;
extern float log1pf ( float ) ;
extern float log2f ( float ) ;
extern float logbf ( float ) ;
extern float modff ( float , float * ) ;
extern float scalbnf ( float , int ) ;
extern float scalblnf ( float , long int ) ;

extern float cbrtf ( float ) ;
extern float fabsf ( float ) ;
extern float hypotf ( float , float ) ;
extern float powf ( float , float ) ;
extern float sqrtf ( float ) ;

extern float erff ( float ) ;
extern float erfcf ( float ) ;
extern float lgammaf ( float ) ;
extern float tgammaf ( float ) ;

extern float ceilf ( float ) ;
extern float floorf ( float ) ;
extern float nearbyintf ( float ) ;
extern float rintf ( float ) ;
extern long int lrintf ( float ) ;
extern float roundf ( float ) ;
extern long int lroundf ( float ) ;
extern float truncf ( float ) ;

extern float fmodf ( float , float ) ;
extern float remainderf ( float , float ) ;
extern float remquof ( float , float , int * ) ;

extern float copysignf ( float , float ) ;
extern float nanf ( const char * ) ;
extern float nextafterf ( float , float ) ;
extern float nexttowardf ( float , long double ) ;

extern float fdimf ( float , float ) ;
extern float fmaxf ( float , float ) ;
extern float fminf ( float , float ) ;

extern float fmaf ( float , float , float ) ;

extern long double acosl ( long double ) ;
extern long double asinl ( long double ) ;
extern long double atanl ( long double ) ;
extern long double atan2l ( long double , long double ) ;
extern long double cosl ( long double ) ;
extern long double sinl ( long double ) ;
extern long double tanl ( long double ) ;

extern long double acoshl ( long double ) ;
extern long double asinhl ( long double ) ;
extern long double atanhl ( long double ) ;
extern long double coshl ( long double ) ;
extern long double sinhl ( long double ) ;
extern long double tanhl ( long double ) ;

extern long double expl ( long double ) ;
extern long double exp2l ( long double ) ;
extern long double expm1l ( long double ) ;
extern long double frexpl ( long double , int * ) ;
extern int ilogbl ( long double ) ;
extern long double ldexpl ( long double , int ) ;
extern long double logl ( long double ) ;
extern long double log10l ( long double ) ;
extern long double log1pl ( long double ) ;
extern long double log2l ( long double ) ;
extern long double logbl ( long double ) ;
extern long double modfl ( long double , long double * ) ;
extern long double scalbnl ( long double , int ) ;
extern long double scalblnl ( long double , long int ) ;

extern long double cbrtl ( long double ) ;
extern long double fabsl ( long double ) ;
extern long double hypotl ( long double , long double ) ;
extern long double powl ( long double , long double ) ;
extern long double sqrtl ( long double ) ;

extern long double erfl ( long double ) ;
extern long double erfcl ( long double ) ;
extern long double lgammal ( long double ) ;
extern long double tgammal ( long double ) ;

extern long double ceill ( long double ) ;
extern long double floorl ( long double ) ;
extern long double nearbyintl ( long double ) ;
extern long double rintl ( long double ) ;
extern long int lrintl ( long double ) ;
extern long double roundl ( long double ) ;
extern long int lroundl ( long double ) ;
extern long double truncl ( long double ) ;

extern long double fmodl ( long double , long double ) ;
extern long double remainderl ( long double , long double ) ;
extern long double remquol ( long double , long double , int * ) ;

extern long double copysignl ( long double , long double ) ;
extern long double nanl ( const char * ) ;
extern long double nextafterl ( long double , long double ) ;
extern long double nexttowardl ( long double , long double ) ;

extern long double fdiml ( long double , long double ) ;
extern long double fmaxl ( long double , long double ) ;
extern long double fminl ( long double , long double ) ;

extern long double fmal ( long double , long double , long double ) ;



extern long long int llrint ( double ) ;
extern long long int llround ( double ) ;

extern long long int llrintf ( float ) ;
extern long long int llroundf ( float ) ;

extern long long int llrintl ( long double ) ;
extern long long int llroundl ( long double ) ;
#517
}
#15 "/usr/include/math.h"
using std :: abs ;
using std :: acos ;
using std :: asin ;
using std :: atan2 ;
using std :: atan ;
using std :: ceil ;
using std :: cos ;
using std :: cosh ;
using std :: exp ;
using std :: fabs ;
using std :: floor ;
using std :: fmod ;
using std :: frexp ;
using std :: ldexp ;
using std :: log10 ;
using std :: log ;
using std :: modf ;
using std :: pow ;
using std :: sin ;
using std :: sinh ;
using std :: sqrt ;
using std :: tan ;
using std :: tanh ;



extern "C" {
#76
extern int signgam ;
#84
enum version { libm_ieee = - 1 , c_issue_4 , ansi_1 , strict_ansi } ;


extern const enum version _lib_version ;




struct exception {
int type ;
char * name ;
double arg1 ;
double arg2 ;
double retval ;
} ;
#130
extern double erf ( double ) ;
extern double erfc ( double ) ;
extern double hypot ( double , double ) ;
extern double lgamma ( double ) ;
#142
extern int isnan ( double ) ;

#pragma does_not_read_global_data ( isnan )
#pragma does_not_write_global_data ( isnan )
#pragma no_side_effect ( isnan )




extern double gamma ( double ) ;

extern double j0 ( double ) ;
extern double j1 ( double ) ;
extern double jn ( int , double ) ;
extern double y0 ( double ) ;
extern double y1 ( double ) ;
extern double yn ( int , double ) ;
#171
extern double scalb ( double , double ) ;
#180
extern double acosh ( double ) ;
extern double asinh ( double ) ;
extern double atanh ( double ) ;
extern double cbrt ( double ) ;
extern double logb ( double ) ;
extern double nextafter ( double , double ) ;
extern double remainder ( double , double ) ;




extern double expm1 ( double ) ;
extern int ilogb ( double ) ;
extern double log1p ( double ) ;
extern double rint ( double ) ;
#214
extern int matherr ( struct exception * ) ;




extern double significand ( double ) ;
#227
extern int signgamf ;
extern int signgaml ;

extern int isnanf ( float ) ;
extern int isnanl ( long double ) ;
extern float gammaf ( float ) ;
extern float gammaf_r ( float , int * ) ;
extern float j0f ( float ) ;
extern float j1f ( float ) ;
extern float jnf ( int , float ) ;
extern float lgammaf_r ( float , int * ) ;
extern float scalbf ( float , float ) ;
extern float significandf ( float ) ;
extern float y0f ( float ) ;
extern float y1f ( float ) ;
extern float ynf ( int , float ) ;
extern long double gammal ( long double ) ;
extern long double gammal_r ( long double , int * ) ;
extern long double j0l ( long double ) ;
extern long double j1l ( long double ) ;
extern long double jnl ( int , long double ) ;
extern long double lgammal_r ( long double , int * ) ;
extern long double scalbl ( long double , long double ) ;
extern long double significandl ( long double ) ;
extern long double y0l ( long double ) ;
extern long double y1l ( long double ) ;
extern long double ynl ( int , long double ) ;
#276
extern void sincos ( double , double * , double * ) ;
extern void sincosf ( float , float * , float * ) ;
extern void sincosl ( long double , long double * , long double * ) ;
#288
extern double copysign ( double , double ) ;
extern double scalbn ( double , int ) ;
#302
extern double gamma_r ( double , int * ) ;
extern double lgamma_r ( double , int * ) ;
#310
extern float modff ( float , float * ) ;
#1 "/usr/include/floatingpoint.h"
#16
#pragma ident "@(#)floatingpoint.h  2.10    09/05/19 SMI"
#1 "/usr/include/sys/ieeefp.h"
#9
#pragma ident "@(#)ieeefp.h 2.12    04/10/23 SMI"


extern "C" {
#51
enum fp_direction_type {
fp_nearest = 0 ,
fp_negative = 1 ,
fp_positive = 2 ,
fp_tozero = 3
} ;

enum fp_precision_type {
fp_single = 0 ,
fp_precision_3 = 1 ,
fp_double = 2 ,
fp_extended = 3
} ;

enum fp_exception_type {
fp_invalid = 0 ,
fp_denormalized = 1 ,
fp_division = 2 ,
fp_overflow = 3 ,
fp_underflow = 4 ,
fp_inexact = 5
} ;

enum fp_trap_enable_type {
fp_trap_invalid = 0 ,
fp_trap_denormalized = 1 ,
fp_trap_division = 2 ,
fp_trap_overflow = 3 ,
fp_trap_underflow = 4 ,
fp_trap_inexact = 5
} ;


enum fp_class_type {
fp_zero = 0 ,
fp_subnormal = 1 ,
fp_normal = 2 ,
fp_infinity = 3 ,
fp_quiet = 4 ,
fp_signaling = 5
} ;


}
#21 "/usr/include/floatingpoint.h"
extern "C" {
#48
namespace std {



typedef __FILE FILE ;


}
#64
typedef int sigfpe_code_type ;

typedef void ( * sigfpe_handler_type ) ( ) ;





extern sigfpe_handler_type sigfpe ( sigfpe_code_type , sigfpe_handler_type ) ;




typedef float single ;



typedef unsigned extended [ 3 ] ;


typedef long double quadruple ;

typedef unsigned fp_exception_field_type ;
#96
typedef char decimal_string [ 512 ] ;


typedef struct {
enum fp_class_type fpclass ;
int sign ;
int exponent ;
decimal_string ds ;


int more ;


int ndigits ;


} decimal_record ;

enum decimal_form {
fixed_form ,



floating_form

} ;

typedef struct {
enum fp_direction_type rd ;

enum decimal_form df ;

int ndigits ;
} decimal_mode ;

enum decimal_string_form {
invalid_form ,
whitespace_form ,
fixed_int_form ,
fixed_intdot_form ,
fixed_dotfrac_form ,
fixed_intdotfrac_form ,
floating_int_form ,
floating_intdot_form ,
floating_dotfrac_form ,
floating_intdotfrac_form ,
inf_form ,
infinity_form ,
nan_form ,
nanstring_form
} ;

extern void single_to_decimal
( single * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;
extern void double_to_decimal
( double * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;
extern void extended_to_decimal
( extended * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;
extern void quadruple_to_decimal
( quadruple * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;

extern void decimal_to_single
( single * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;
extern void decimal_to_double
( double * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;
extern void decimal_to_extended
( extended * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;
extern void decimal_to_quadruple
( quadruple * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ;

extern void string_to_decimal
( char * * , int , int , decimal_record * , enum decimal_string_form * , char * * ) ;
extern void func_to_decimal

( char * * , int , int , decimal_record * , enum decimal_string_form * , char * * , int ( * ) ( void ) , int * , int ( *
#170
) ( int ) ) ;
extern void file_to_decimal

( char * * , int , int , decimal_record * , enum decimal_string_form * , char * * , std :: FILE * , int * ) ;

extern char * seconvert ( single * , int , int * , int * , char * ) ;
extern char * sfconvert ( single * , int , int * , int * , char * ) ;
extern char * sgconvert ( single * , int , int , char * ) ;
extern char * econvert ( double , int , int * , int * , char * ) ;
extern char * fconvert ( double , int , int * , int * , char * ) ;
extern char * gconvert ( double , int , int , char * ) ;
extern char * qeconvert ( quadruple * , int , int * , int * , char * ) ;
extern char * qfconvert ( quadruple * , int , int * , int * , char * ) ;
extern char * qgconvert ( quadruple * , int , int , char * ) ;

extern char * ecvt ( double , int , int * , int * ) ;
extern char * fcvt ( double , int , int * , int * ) ;
extern char * gcvt ( double , int , char * ) ;





extern double atof ( const char * ) ;
extern double strtod ( const char * , char * * ) ;




}
#329 "/usr/include/math.h"
}
#75 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cmath"
namespace std
{
#95
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
abs ( _Tp __x )
{ return __builtin_fabs ( __x ) ; }

using :: acos ;
#114
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
acos ( _Tp __x )
{ return __builtin_acos ( __x ) ; }

using :: asin ;
#133
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
asin ( _Tp __x )
{ return __builtin_asin ( __x ) ; }

using :: atan ;
#152
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
atan ( _Tp __x )
{ return __builtin_atan ( __x ) ; }

using :: atan2 ;
#171
template < typename _Tp , typename _Up >
inline constexpr
typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
atan2 ( _Tp __y , _Up __x )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return atan2 ( __type ( __y ) , __type ( __x ) ) ;
}

using :: ceil ;
#192
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
ceil ( _Tp __x )
{ return __builtin_ceil ( __x ) ; }

using :: cos ;
#211
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
cos ( _Tp __x )
{ return __builtin_cos ( __x ) ; }

using :: cosh ;
#230
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
cosh ( _Tp __x )
{ return __builtin_cosh ( __x ) ; }

using :: exp ;
#249
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
exp ( _Tp __x )
{ return __builtin_exp ( __x ) ; }

using :: fabs ;
#268
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
fabs ( _Tp __x )
{ return __builtin_fabs ( __x ) ; }

using :: floor ;
#287
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
floor ( _Tp __x )
{ return __builtin_floor ( __x ) ; }

using :: fmod ;
#306
template < typename _Tp , typename _Up >
inline constexpr
typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
fmod ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return fmod ( __type ( __x ) , __type ( __y ) ) ;
}

using :: frexp ;
#327
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
frexp ( _Tp __x , int * __exp )
{ return __builtin_frexp ( __x , __exp ) ; }

using :: ldexp ;
#346
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
ldexp ( _Tp __x , int __exp )
{ return __builtin_ldexp ( __x , __exp ) ; }

using :: log ;
#365
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
log ( _Tp __x )
{ return __builtin_log ( __x ) ; }

using :: log10 ;
#384
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
log10 ( _Tp __x )
{ return __builtin_log10 ( __x ) ; }

using :: modf ;
#403
using :: pow ;
#431
template < typename _Tp , typename _Up >
inline constexpr
typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
pow ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return pow ( __type ( __x ) , __type ( __y ) ) ;
}

using :: sin ;
#452
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
sin ( _Tp __x )
{ return __builtin_sin ( __x ) ; }

using :: sinh ;
#471
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
sinh ( _Tp __x )
{ return __builtin_sinh ( __x ) ; }

using :: sqrt ;
#490
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
sqrt ( _Tp __x )
{ return __builtin_sqrt ( __x ) ; }

using :: tan ;
#509
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
tan ( _Tp __x )
{ return __builtin_tan ( __x ) ; }

using :: tanh ;
#528
template < typename _Tp >
inline constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
tanh ( _Tp __x )
{ return __builtin_tanh ( __x ) ; }


}
#555
namespace std
{



constexpr int
fpclassify ( float __x )
{ return __builtin_fpclassify ( 4 , 3 , 2 ,
1 , 0 , __x ) ; }

constexpr int
fpclassify ( double __x )
{ return __builtin_fpclassify ( 4 , 3 , 2 ,
1 , 0 , __x ) ; }

constexpr int
fpclassify ( long double __x )
{ return __builtin_fpclassify ( 4 , 3 , 2 ,
1 , 0 , __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
int > :: __type
fpclassify ( _Tp __x )
{ return __x != 0 ? 2 : 0 ; }

constexpr bool
isfinite ( float __x )
{ return __oracle_builtin_isfinite ( __x ) ; }

constexpr bool
isfinite ( double __x )
{ return __oracle_builtin_isfinite ( __x ) ; }

constexpr bool
isfinite ( long double __x )
{ return __oracle_builtin_isfinite ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
bool > :: __type
isfinite ( _Tp __x )
{ return true ; }

constexpr bool
isinf ( float __x )
{ return __oracle_builtin_isinf ( __x ) ; }

constexpr bool
isinf ( double __x )
{ return __oracle_builtin_isinf ( __x ) ; }

constexpr bool
isinf ( long double __x )
{ return __oracle_builtin_isinf ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
bool > :: __type
isinf ( _Tp __x )
{ return false ; }

constexpr bool
isnan ( float __x )
{ return __oracle_builtin_isnan ( __x ) ; }

constexpr bool
isnan ( double __x )
{ return __oracle_builtin_isnan ( __x ) ; }

constexpr bool
isnan ( long double __x )
{ return __oracle_builtin_isnan ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
bool > :: __type
isnan ( _Tp __x )
{ return false ; }

constexpr bool
isnormal ( float __x )
{ return __oracle_builtin_isnormal ( __x ) ; }

constexpr bool
isnormal ( double __x )
{ return __oracle_builtin_isnormal ( __x ) ; }

constexpr bool
isnormal ( long double __x )
{ return __oracle_builtin_isnormal ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
bool > :: __type
isnormal ( _Tp __x )
{ return __x != 0 ? true : false ; }

constexpr bool
signbit ( float __x )
{ return __oracle_builtin_signbit ( __x ) ; }

constexpr bool
signbit ( double __x )
{ return __oracle_builtin_signbit ( __x ) ; }

constexpr bool
signbit ( long double __x )
{ return __oracle_builtin_signbit ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
bool > :: __type
signbit ( _Tp __x )
{ return __x < 0 ? true : false ; }

constexpr bool
isgreater ( float __x , float __y )
{ return __oracle_builtin_isgreater ( __x , __y ) ; }

constexpr bool
isgreater ( double __x , double __y )
{ return __oracle_builtin_isgreater ( __x , __y ) ; }

constexpr bool
isgreater ( long double __x , long double __y )
{ return __oracle_builtin_isgreater ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename
__gnu_cxx :: __enable_if < ( __is_arithmetic < _Tp > :: __value
&& __is_arithmetic < _Up > :: __value ) , bool > :: __type
isgreater ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return __oracle_builtin_isgreater ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr bool
isgreaterequal ( float __x , float __y )
{ return __oracle_builtin_isgreaterequal ( __x , __y ) ; }

constexpr bool
isgreaterequal ( double __x , double __y )
{ return __oracle_builtin_isgreaterequal ( __x , __y ) ; }

constexpr bool
isgreaterequal ( long double __x , long double __y )
{ return __oracle_builtin_isgreaterequal ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename
__gnu_cxx :: __enable_if < ( __is_arithmetic < _Tp > :: __value
&& __is_arithmetic < _Up > :: __value ) , bool > :: __type
isgreaterequal ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return __oracle_builtin_isgreaterequal ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr bool
isless ( float __x , float __y )
{ return __oracle_builtin_isless ( __x , __y ) ; }

constexpr bool
isless ( double __x , double __y )
{ return __oracle_builtin_isless ( __x , __y ) ; }

constexpr bool
isless ( long double __x , long double __y )
{ return __oracle_builtin_isless ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename
__gnu_cxx :: __enable_if < ( __is_arithmetic < _Tp > :: __value
&& __is_arithmetic < _Up > :: __value ) , bool > :: __type
isless ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return __oracle_builtin_isless ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr bool
islessequal ( float __x , float __y )
{ return __oracle_builtin_islessequal ( __x , __y ) ; }

constexpr bool
islessequal ( double __x , double __y )
{ return __oracle_builtin_islessequal ( __x , __y ) ; }

constexpr bool
islessequal ( long double __x , long double __y )
{ return __oracle_builtin_islessequal ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename
__gnu_cxx :: __enable_if < ( __is_arithmetic < _Tp > :: __value
&& __is_arithmetic < _Up > :: __value ) , bool > :: __type
islessequal ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return __oracle_builtin_islessequal ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr bool
islessgreater ( float __x , float __y )
{ return __oracle_builtin_islessgreater ( __x , __y ) ; }

constexpr bool
islessgreater ( double __x , double __y )
{ return __oracle_builtin_islessgreater ( __x , __y ) ; }

constexpr bool
islessgreater ( long double __x , long double __y )
{ return __oracle_builtin_islessgreater ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename
__gnu_cxx :: __enable_if < ( __is_arithmetic < _Tp > :: __value
&& __is_arithmetic < _Up > :: __value ) , bool > :: __type
islessgreater ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return __oracle_builtin_islessgreater ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr bool
isunordered ( float __x , float __y )
{ return __oracle_builtin_isunordered ( __x , __y ) ; }

constexpr bool
isunordered ( double __x , double __y )
{ return __oracle_builtin_isunordered ( __x , __y ) ; }

constexpr bool
isunordered ( long double __x , long double __y )
{ return __oracle_builtin_isunordered ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename
__gnu_cxx :: __enable_if < ( __is_arithmetic < _Tp > :: __value
&& __is_arithmetic < _Up > :: __value ) , bool > :: __type
isunordered ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return __oracle_builtin_isunordered ( __type ( __x ) , __type ( __y ) ) ;
}
#917
}
#1032
namespace std
{



using :: double_t ;
using :: float_t ;


using :: acosh ;
using :: acoshf ;
using :: acoshl ;

using :: asinh ;
using :: asinhf ;
using :: asinhl ;

using :: atanh ;
using :: atanhf ;
using :: atanhl ;

using :: cbrt ;
using :: cbrtf ;
using :: cbrtl ;

using :: copysign ;
using :: copysignf ;
using :: copysignl ;

using :: erf ;
using :: erff ;
using :: erfl ;

using :: erfc ;
using :: erfcf ;
using :: erfcl ;

using :: exp2 ;
using :: exp2f ;
using :: exp2l ;

using :: expm1 ;
using :: expm1f ;
using :: expm1l ;

using :: fdim ;
using :: fdimf ;
using :: fdiml ;

using :: fma ;
using :: fmaf ;
using :: fmal ;

using :: fmax ;
using :: fmaxf ;
using :: fmaxl ;

using :: fmin ;
using :: fminf ;
using :: fminl ;

using :: hypot ;
using :: hypotf ;
using :: hypotl ;

using :: ilogb ;
using :: ilogbf ;
using :: ilogbl ;

using :: lgamma ;
using :: lgammaf ;
using :: lgammal ;

using :: llrint ;
using :: llrintf ;
using :: llrintl ;

using :: llround ;
using :: llroundf ;
using :: llroundl ;

using :: log1p ;
using :: log1pf ;
using :: log1pl ;

using :: log2 ;
using :: log2f ;
using :: log2l ;

using :: logb ;
using :: logbf ;
using :: logbl ;

using :: lrint ;
using :: lrintf ;
using :: lrintl ;

using :: lround ;
using :: lroundf ;
using :: lroundl ;

using :: nan ;
using :: nanf ;
using :: nanl ;

using :: nearbyint ;
using :: nearbyintf ;
using :: nearbyintl ;

using :: nextafter ;
using :: nextafterf ;
using :: nextafterl ;

using :: nexttoward ;
using :: nexttowardf ;
using :: nexttowardl ;

using :: remainder ;
using :: remainderf ;
using :: remainderl ;

using :: remquo ;
using :: remquof ;
using :: remquol ;

using :: rint ;
using :: rintf ;
using :: rintl ;

using :: round ;
using :: roundf ;
using :: roundl ;

using :: scalbln ;
using :: scalblnf ;
using :: scalblnl ;

using :: scalbn ;
using :: scalbnf ;
using :: scalbnl ;

using :: tgamma ;
using :: tgammaf ;
using :: tgammal ;

using :: trunc ;
using :: truncf ;
using :: truncl ;


constexpr float
acosh ( float __x )
{ return __builtin_acoshf ( __x ) ; }

constexpr long double
acosh ( long double __x )
{ return __builtin_acoshl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
acosh ( _Tp __x )
{ return __builtin_acosh ( __x ) ; }

constexpr float
asinh ( float __x )
{ return __builtin_asinhf ( __x ) ; }

constexpr long double
asinh ( long double __x )
{ return __builtin_asinhl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
asinh ( _Tp __x )
{ return __builtin_asinh ( __x ) ; }

constexpr float
atanh ( float __x )
{ return __builtin_atanhf ( __x ) ; }

constexpr long double
atanh ( long double __x )
{ return __builtin_atanhl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
atanh ( _Tp __x )
{ return __builtin_atanh ( __x ) ; }

constexpr float
cbrt ( float __x )
{ return __builtin_cbrtf ( __x ) ; }

constexpr long double
cbrt ( long double __x )
{ return __builtin_cbrtl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
cbrt ( _Tp __x )
{ return __builtin_cbrt ( __x ) ; }

constexpr float
copysign ( float __x , float __y )
{ return __builtin_copysignf ( __x , __y ) ; }

constexpr long double
copysign ( long double __x , long double __y )
{ return __builtin_copysignl ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
copysign ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return copysign ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr float
erf ( float __x )
{ return __builtin_erff ( __x ) ; }

constexpr long double
erf ( long double __x )
{ return __builtin_erfl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
erf ( _Tp __x )
{ return __builtin_erf ( __x ) ; }

constexpr float
erfc ( float __x )
{ return __builtin_erfcf ( __x ) ; }

constexpr long double
erfc ( long double __x )
{ return __builtin_erfcl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
erfc ( _Tp __x )
{ return __builtin_erfc ( __x ) ; }

constexpr float
exp2 ( float __x )
{ return __builtin_exp2f ( __x ) ; }

constexpr long double
exp2 ( long double __x )
{ return __builtin_exp2l ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
exp2 ( _Tp __x )
{ return __builtin_exp2 ( __x ) ; }

constexpr float
expm1 ( float __x )
{ return __builtin_expm1f ( __x ) ; }

constexpr long double
expm1 ( long double __x )
{ return __builtin_expm1l ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
expm1 ( _Tp __x )
{ return __builtin_expm1 ( __x ) ; }

constexpr float
fdim ( float __x , float __y )
{ return __builtin_fdimf ( __x , __y ) ; }

constexpr long double
fdim ( long double __x , long double __y )
{ return __builtin_fdiml ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
fdim ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return fdim ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr float
fma ( float __x , float __y , float __z )
{ return __builtin_fmaf ( __x , __y , __z ) ; }

constexpr long double
fma ( long double __x , long double __y , long double __z )
{ return __builtin_fmal ( __x , __y , __z ) ; }

template < typename _Tp , typename _Up , typename _Vp >
constexpr typename __gnu_cxx :: __promote_3 < _Tp , _Up , _Vp > :: __type
fma ( _Tp __x , _Up __y , _Vp __z )
{
typedef typename __gnu_cxx :: __promote_3 < _Tp , _Up , _Vp > :: __type __type ;
return fma ( __type ( __x ) , __type ( __y ) , __type ( __z ) ) ;
}

constexpr float
fmax ( float __x , float __y )
{ return __builtin_fmaxf ( __x , __y ) ; }

constexpr long double
fmax ( long double __x , long double __y )
{ return __builtin_fmaxl ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
fmax ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return fmax ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr float
fmin ( float __x , float __y )
{ return __builtin_fminf ( __x , __y ) ; }

constexpr long double
fmin ( long double __x , long double __y )
{ return __builtin_fminl ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
fmin ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return fmin ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr float
hypot ( float __x , float __y )
{ return __builtin_hypotf ( __x , __y ) ; }

constexpr long double
hypot ( long double __x , long double __y )
{ return __builtin_hypotl ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
hypot ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return hypot ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr int
ilogb ( float __x )
{ return __builtin_ilogbf ( __x ) ; }

constexpr int
ilogb ( long double __x )
{ return __builtin_ilogbl ( __x ) ; }

template < typename _Tp >
constexpr
typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
int > :: __type
ilogb ( _Tp __x )
{ return __builtin_ilogb ( __x ) ; }

constexpr float
lgamma ( float __x )
{ return __builtin_lgammaf ( __x ) ; }

constexpr long double
lgamma ( long double __x )
{ return __builtin_lgammal ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
lgamma ( _Tp __x )
{ return __builtin_lgamma ( __x ) ; }

constexpr long long
llrint ( float __x )
{ return __builtin_llrintf ( __x ) ; }

constexpr long long
llrint ( long double __x )
{ return __builtin_llrintl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
long long > :: __type
llrint ( _Tp __x )
{ return __builtin_llrint ( __x ) ; }

constexpr long long
llround ( float __x )
{ return __builtin_llroundf ( __x ) ; }

constexpr long long
llround ( long double __x )
{ return __builtin_llroundl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
long long > :: __type
llround ( _Tp __x )
{ return __builtin_llround ( __x ) ; }

constexpr float
log1p ( float __x )
{ return __builtin_log1pf ( __x ) ; }

constexpr long double
log1p ( long double __x )
{ return __builtin_log1pl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
log1p ( _Tp __x )
{ return __builtin_log1p ( __x ) ; }


constexpr float
log2 ( float __x )
{ return __builtin_log2f ( __x ) ; }

constexpr long double
log2 ( long double __x )
{ return __builtin_log2l ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
log2 ( _Tp __x )
{ return __builtin_log2 ( __x ) ; }

constexpr float
logb ( float __x )
{ return __builtin_logbf ( __x ) ; }

constexpr long double
logb ( long double __x )
{ return __builtin_logbl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
logb ( _Tp __x )
{ return __builtin_logb ( __x ) ; }

constexpr long
lrint ( float __x )
{ return __builtin_lrintf ( __x ) ; }

constexpr long
lrint ( long double __x )
{ return __builtin_lrintl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
long > :: __type
lrint ( _Tp __x )
{ return __builtin_lrint ( __x ) ; }

constexpr long
lround ( float __x )
{ return __builtin_lroundf ( __x ) ; }

constexpr long
lround ( long double __x )
{ return __builtin_lroundl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
long > :: __type
lround ( _Tp __x )
{ return __builtin_lround ( __x ) ; }

constexpr float
nearbyint ( float __x )
{ return __builtin_nearbyintf ( __x ) ; }

constexpr long double
nearbyint ( long double __x )
{ return __builtin_nearbyintl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
nearbyint ( _Tp __x )
{ return __builtin_nearbyint ( __x ) ; }

constexpr float
nextafter ( float __x , float __y )
{ return __builtin_nextafterf ( __x , __y ) ; }

constexpr long double
nextafter ( long double __x , long double __y )
{ return __builtin_nextafterl ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
nextafter ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return nextafter ( __type ( __x ) , __type ( __y ) ) ;
}

constexpr float
nexttoward ( float __x , long double __y )
{ return __builtin_nexttowardf ( __x , __y ) ; }

constexpr long double
nexttoward ( long double __x , long double __y )
{ return __builtin_nexttowardl ( __x , __y ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
nexttoward ( _Tp __x , long double __y )
{ return __builtin_nexttoward ( __x , __y ) ; }

constexpr float
remainder ( float __x , float __y )
{ return __builtin_remainderf ( __x , __y ) ; }

constexpr long double
remainder ( long double __x , long double __y )
{ return __builtin_remainderl ( __x , __y ) ; }

template < typename _Tp , typename _Up >
constexpr typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
remainder ( _Tp __x , _Up __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return remainder ( __type ( __x ) , __type ( __y ) ) ;
}

inline float
remquo ( float __x , float __y , int * __pquo )
{ return __builtin_remquof ( __x , __y , __pquo ) ; }

inline long double
remquo ( long double __x , long double __y , int * __pquo )
{ return __builtin_remquol ( __x , __y , __pquo ) ; }

template < typename _Tp , typename _Up >
inline typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type
remquo ( _Tp __x , _Up __y , int * __pquo )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return remquo ( __type ( __x ) , __type ( __y ) , __pquo ) ;
}

constexpr float
rint ( float __x )
{ return __builtin_rintf ( __x ) ; }

constexpr long double
rint ( long double __x )
{ return __builtin_rintl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
rint ( _Tp __x )
{ return __builtin_rint ( __x ) ; }

constexpr float
round ( float __x )
{ return __builtin_roundf ( __x ) ; }

constexpr long double
round ( long double __x )
{ return __builtin_roundl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
round ( _Tp __x )
{ return __builtin_round ( __x ) ; }

constexpr float
scalbln ( float __x , long __ex )
{ return __builtin_scalblnf ( __x , __ex ) ; }

constexpr long double
scalbln ( long double __x , long __ex )
{ return __builtin_scalblnl ( __x , __ex ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
scalbln ( _Tp __x , long __ex )
{ return __builtin_scalbln ( __x , __ex ) ; }

constexpr float
scalbn ( float __x , int __ex )
{ return __builtin_scalbnf ( __x , __ex ) ; }

constexpr long double
scalbn ( long double __x , int __ex )
{ return __builtin_scalbnl ( __x , __ex ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
scalbn ( _Tp __x , int __ex )
{ return __builtin_scalbn ( __x , __ex ) ; }

constexpr float
tgamma ( float __x )
{ return __builtin_tgammaf ( __x ) ; }

constexpr long double
tgamma ( long double __x )
{ return __builtin_tgammal ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
tgamma ( _Tp __x )
{ return __builtin_tgamma ( __x ) ; }

constexpr float
trunc ( float __x )
{ return __builtin_truncf ( __x ) ; }

constexpr long double
trunc ( long double __x )
{ return __builtin_truncl ( __x ) ; }

template < typename _Tp >
constexpr typename __gnu_cxx :: __enable_if < __is_integer < _Tp > :: __value ,
double > :: __type
trunc ( _Tp __x )
{ return __builtin_trunc ( __x ) ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/limits"
#40
#pragma GCC system_header
#147
namespace std
{
#156
enum float_round_style
{
round_indeterminate = - 1 ,
round_toward_zero = 0 ,
round_to_nearest = 1 ,
round_toward_infinity = 2 ,
round_toward_neg_infinity = 3
} ;
#171
enum float_denorm_style
{

denorm_indeterminate = - 1 ,

denorm_absent = 0 ,

denorm_present = 1
} ;
#191
struct __numeric_limits_base
{


static constexpr bool is_specialized = false ;




static constexpr int digits = 0 ;


static constexpr int digits10 = 0 ;




static constexpr int max_digits10 = 0 ;



static constexpr bool is_signed = false ;


static constexpr bool is_integer = false ;




static constexpr bool is_exact = false ;



static constexpr int radix = 0 ;



static constexpr int min_exponent = 0 ;



static constexpr int min_exponent10 = 0 ;




static constexpr int max_exponent = 0 ;



static constexpr int max_exponent10 = 0 ;


static constexpr bool has_infinity = false ;



static constexpr bool has_quiet_NaN = false ;



static constexpr bool has_signaling_NaN = false ;


static constexpr float_denorm_style has_denorm = denorm_absent ;



static constexpr bool has_denorm_loss = false ;



static constexpr bool is_iec559 = false ;




static constexpr bool is_bounded = false ;
#277
static constexpr bool is_modulo = false ;


static constexpr bool traps = false ;


static constexpr bool tinyness_before = false ;




static constexpr float_round_style round_style =
round_toward_zero ;
} ;
#303
template < typename _Tp >
struct numeric_limits : public __numeric_limits_base
{


static constexpr _Tp
min ( ) noexcept { return _Tp ( ) ; }


static constexpr _Tp
max ( ) noexcept { return _Tp ( ) ; }




static constexpr _Tp
lowest ( ) noexcept { return _Tp ( ) ; }




static constexpr _Tp
epsilon ( ) noexcept { return _Tp ( ) ; }


static constexpr _Tp
round_error ( ) noexcept { return _Tp ( ) ; }


static constexpr _Tp
infinity ( ) noexcept { return _Tp ( ) ; }



static constexpr _Tp
quiet_NaN ( ) noexcept { return _Tp ( ) ; }



static constexpr _Tp
signaling_NaN ( ) noexcept { return _Tp ( ) ; }




static constexpr _Tp
denorm_min ( ) noexcept { return _Tp ( ) ; }
} ;


template < typename _Tp >
struct numeric_limits < const _Tp >
: public numeric_limits < _Tp > { } ;

template < typename _Tp >
struct numeric_limits < volatile _Tp >
: public numeric_limits < _Tp > { } ;

template < typename _Tp >
struct numeric_limits < const volatile _Tp >
: public numeric_limits < _Tp > { } ;
#370
template < >
struct numeric_limits < bool >
{
static constexpr bool is_specialized = true ;

static constexpr bool
min ( ) noexcept { return false ; }

static constexpr bool
max ( ) noexcept { return true ; }


static constexpr bool
lowest ( ) noexcept { return min ( ) ; }

static constexpr int digits = 1 ;
static constexpr int digits10 = 0 ;

static constexpr int max_digits10 = 0 ;

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

static constexpr bool
epsilon ( ) noexcept { return false ; }

static constexpr bool
round_error ( ) noexcept { return false ; }

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

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

static constexpr bool
infinity ( ) noexcept { return false ; }

static constexpr bool
quiet_NaN ( ) noexcept { return false ; }

static constexpr bool
signaling_NaN ( ) noexcept { return false ; }

static constexpr bool
denorm_min ( ) noexcept { return false ; }

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




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


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

static constexpr char
min ( ) noexcept { return ( ( ( char ) ( - 1 ) < 0 ) ? - ( ( ( char ) ( - 1 ) < 0 ) ? ( ( ( ( ( char ) 1 << ( ( sizeof (
#445
char ) * 8 - ( ( char ) ( - 1 ) < 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( char ) 0 ) - 1 : ( char ) 0 ) ; }

static constexpr char
max ( ) noexcept { return ( ( ( char ) ( - 1 ) < 0 ) ? ( ( ( ( ( char ) 1 << ( ( sizeof ( char ) * 8 - ( ( char ) ( - 1 )
#448
< 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( char ) 0 ) ; }


static constexpr char
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

static constexpr bool is_signed = ( ( char ) ( - 1 ) < 0 ) ;
static constexpr bool is_integer = true ;
static constexpr bool is_exact = true ;
static constexpr int radix = 2 ;

static constexpr char
epsilon ( ) noexcept { return 0 ; }

static constexpr char
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr
char infinity ( ) noexcept { return char ( ) ; }

static constexpr char
quiet_NaN ( ) noexcept { return char ( ) ; }

static constexpr char
signaling_NaN ( ) noexcept { return char ( ) ; }

static constexpr char
denorm_min ( ) noexcept { return static_cast < char > ( 0 ) ; }

static constexpr bool is_iec559 = false ;
static constexpr bool is_bounded = true ;
static constexpr bool is_modulo = ! is_signed ;

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


template < >
struct numeric_limits < signed char >
{
static constexpr bool is_specialized = true ;

static constexpr signed char
min ( ) noexcept { return - 127 - 1 ; }

static constexpr signed char
max ( ) noexcept { return 127 ; }


static constexpr signed char
lowest ( ) noexcept { return min ( ) ; }


static constexpr int digits = ( sizeof ( signed char ) * 8 - ( ( signed char ) ( - 1 ) < 0 ) ) ;
static constexpr int digits10
= ( ( sizeof ( signed char ) * 8 - ( ( signed char ) ( - 1 ) < 0 ) ) * 643L / 2136 ) ;

static constexpr int max_digits10 = 0 ;

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

static constexpr signed char
epsilon ( ) noexcept { return 0 ; }

static constexpr signed char
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr signed char
infinity ( ) noexcept { return static_cast < signed char > ( 0 ) ; }

static constexpr signed char
quiet_NaN ( ) noexcept { return static_cast < signed char > ( 0 ) ; }

static constexpr signed char
signaling_NaN ( ) noexcept
{ return static_cast < signed char > ( 0 ) ; }

static constexpr signed char
denorm_min ( ) noexcept
{ return static_cast < signed char > ( 0 ) ; }

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

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


template < >
struct numeric_limits < unsigned char >
{
static constexpr bool is_specialized = true ;

static constexpr unsigned char
min ( ) noexcept { return 0 ; }

static constexpr unsigned char
max ( ) noexcept { return 127 * 2U + 1 ; }


static constexpr unsigned char
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr unsigned char
epsilon ( ) noexcept { return 0 ; }

static constexpr unsigned char
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr unsigned char
infinity ( ) noexcept
{ return static_cast < unsigned char > ( 0 ) ; }

static constexpr unsigned char
quiet_NaN ( ) noexcept
{ return static_cast < unsigned char > ( 0 ) ; }

static constexpr unsigned char
signaling_NaN ( ) noexcept
{ return static_cast < unsigned char > ( 0 ) ; }

static constexpr unsigned char
denorm_min ( ) noexcept
{ return static_cast < unsigned char > ( 0 ) ; }

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

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


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

static constexpr wchar_t
min ( ) noexcept { return ( ( ( wchar_t ) ( - 1 ) < 0 ) ? - ( ( ( wchar_t ) ( - 1 ) < 0 ) ? ( ( ( ( ( wchar_t ) 1 << ( (
#655
sizeof ( wchar_t ) * 8 - ( ( wchar_t ) ( - 1 ) < 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( wchar_t ) 0 ) - 1 : ( wchar_t ) 0
#655
) ; }

static constexpr wchar_t
max ( ) noexcept { return ( ( ( wchar_t ) ( - 1 ) < 0 ) ? ( ( ( ( ( wchar_t ) 1 << ( ( sizeof ( wchar_t ) * 8 - ( ( wchar_t
#658
) ( - 1 ) < 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( wchar_t ) 0 ) ; }


static constexpr wchar_t
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

static constexpr bool is_signed = ( ( wchar_t ) ( - 1 ) < 0 ) ;
static constexpr bool is_integer = true ;
static constexpr bool is_exact = true ;
static constexpr int radix = 2 ;

static constexpr wchar_t
epsilon ( ) noexcept { return 0 ; }

static constexpr wchar_t
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr wchar_t
infinity ( ) noexcept { return wchar_t ( ) ; }

static constexpr wchar_t
quiet_NaN ( ) noexcept { return wchar_t ( ) ; }

static constexpr wchar_t
signaling_NaN ( ) noexcept { return wchar_t ( ) ; }

static constexpr wchar_t
denorm_min ( ) noexcept { return wchar_t ( ) ; }

static constexpr bool is_iec559 = false ;
static constexpr bool is_bounded = true ;
static constexpr bool is_modulo = ! is_signed ;

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



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

static constexpr char16_t
min ( ) noexcept { return ( ( ( char16_t ) ( - 1 ) < 0 ) ? - ( ( ( char16_t ) ( - 1 ) < 0 ) ? ( ( ( ( ( char16_t ) 1 << (
#724
( sizeof ( char16_t ) * 8 - ( ( char16_t ) ( - 1 ) < 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( char16_t ) 0 ) - 1 : ( char16_t
#724
) 0 ) ; }

static constexpr char16_t
max ( ) noexcept { return ( ( ( char16_t ) ( - 1 ) < 0 ) ? ( ( ( ( ( char16_t ) 1 << ( ( sizeof ( char16_t ) * 8 - ( ( char16_t
#727
) ( - 1 ) < 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( char16_t ) 0 ) ; }

static constexpr char16_t
lowest ( ) noexcept { return min ( ) ; }

static constexpr int digits = ( sizeof ( char16_t ) * 8 - ( ( char16_t ) ( - 1 ) < 0 ) ) ;
static constexpr int digits10 = ( ( sizeof ( char16_t ) * 8 - ( ( char16_t ) ( - 1 ) < 0 ) ) * 643L / 2136 ) ;
static constexpr int max_digits10 = 0 ;
static constexpr bool is_signed = ( ( char16_t ) ( - 1 ) < 0 ) ;
static constexpr bool is_integer = true ;
static constexpr bool is_exact = true ;
static constexpr int radix = 2 ;

static constexpr char16_t
epsilon ( ) noexcept { return 0 ; }

static constexpr char16_t
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr char16_t
infinity ( ) noexcept { return char16_t ( ) ; }

static constexpr char16_t
quiet_NaN ( ) noexcept { return char16_t ( ) ; }

static constexpr char16_t
signaling_NaN ( ) noexcept { return char16_t ( ) ; }

static constexpr char16_t
denorm_min ( ) noexcept { return char16_t ( ) ; }

static constexpr bool is_iec559 = false ;
static constexpr bool is_bounded = true ;
static constexpr bool is_modulo = ! is_signed ;

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


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

static constexpr char32_t
min ( ) noexcept { return ( ( ( char32_t ) ( - 1 ) < 0 ) ? - ( ( ( char32_t ) ( - 1 ) < 0 ) ? ( ( ( ( ( char32_t ) 1 << (
#785
( sizeof ( char32_t ) * 8 - ( ( char32_t ) ( - 1 ) < 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( char32_t ) 0 ) - 1 : ( char32_t
#785
) 0 ) ; }

static constexpr char32_t
max ( ) noexcept { return ( ( ( char32_t ) ( - 1 ) < 0 ) ? ( ( ( ( ( char32_t ) 1 << ( ( sizeof ( char32_t ) * 8 - ( ( char32_t
#788
) ( - 1 ) < 0 ) ) - 1 ) ) - 1 ) << 1 ) + 1 ) : ~ ( char32_t ) 0 ) ; }

static constexpr char32_t
lowest ( ) noexcept { return min ( ) ; }

static constexpr int digits = ( sizeof ( char32_t ) * 8 - ( ( char32_t ) ( - 1 ) < 0 ) ) ;
static constexpr int digits10 = ( ( sizeof ( char32_t ) * 8 - ( ( char32_t ) ( - 1 ) < 0 ) ) * 643L / 2136 ) ;
static constexpr int max_digits10 = 0 ;
static constexpr bool is_signed = ( ( char32_t ) ( - 1 ) < 0 ) ;
static constexpr bool is_integer = true ;
static constexpr bool is_exact = true ;
static constexpr int radix = 2 ;

static constexpr char32_t
epsilon ( ) noexcept { return 0 ; }

static constexpr char32_t
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr char32_t
infinity ( ) noexcept { return char32_t ( ) ; }

static constexpr char32_t
quiet_NaN ( ) noexcept { return char32_t ( ) ; }

static constexpr char32_t
signaling_NaN ( ) noexcept { return char32_t ( ) ; }

static constexpr char32_t
denorm_min ( ) noexcept { return char32_t ( ) ; }

static constexpr bool is_iec559 = false ;
static constexpr bool is_bounded = true ;
static constexpr bool is_modulo = ! is_signed ;

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



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

static constexpr short
min ( ) noexcept { return - 32767 - 1 ; }

static constexpr short
max ( ) noexcept { return 32767 ; }


static constexpr short
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr short
epsilon ( ) noexcept { return 0 ; }

static constexpr short
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr short
infinity ( ) noexcept { return short ( ) ; }

static constexpr short
quiet_NaN ( ) noexcept { return short ( ) ; }

static constexpr short
signaling_NaN ( ) noexcept { return short ( ) ; }

static constexpr short
denorm_min ( ) noexcept { return short ( ) ; }

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

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


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

static constexpr unsigned short
min ( ) noexcept { return 0 ; }

static constexpr unsigned short
max ( ) noexcept { return 32767 * 2U + 1 ; }


static constexpr unsigned short
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr unsigned short
epsilon ( ) noexcept { return 0 ; }

static constexpr unsigned short
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr unsigned short
infinity ( ) noexcept
{ return static_cast < unsigned short > ( 0 ) ; }

static constexpr unsigned short
quiet_NaN ( ) noexcept
{ return static_cast < unsigned short > ( 0 ) ; }

static constexpr unsigned short
signaling_NaN ( ) noexcept
{ return static_cast < unsigned short > ( 0 ) ; }

static constexpr unsigned short
denorm_min ( ) noexcept
{ return static_cast < unsigned short > ( 0 ) ; }

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

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


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

static constexpr int
min ( ) noexcept { return - 2147483647 - 1 ; }

static constexpr int
max ( ) noexcept { return 2147483647 ; }


static constexpr int
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr int
epsilon ( ) noexcept { return 0 ; }

static constexpr int
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr int
infinity ( ) noexcept { return static_cast < int > ( 0 ) ; }

static constexpr int
quiet_NaN ( ) noexcept { return static_cast < int > ( 0 ) ; }

static constexpr int
signaling_NaN ( ) noexcept { return static_cast < int > ( 0 ) ; }

static constexpr int
denorm_min ( ) noexcept { return static_cast < int > ( 0 ) ; }

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

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


template < >
struct numeric_limits < unsigned int >
{
static constexpr bool is_specialized = true ;

static constexpr unsigned int
min ( ) noexcept { return 0 ; }

static constexpr unsigned int
max ( ) noexcept { return 2147483647 * 2U + 1 ; }


static constexpr unsigned int
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr unsigned int
epsilon ( ) noexcept { return 0 ; }

static constexpr unsigned int
round_error ( ) noexcept { return 0 ; }

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

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

static constexpr unsigned int
infinity ( ) noexcept { return static_cast < unsigned int > ( 0 ) ; }

static constexpr unsigned int
quiet_NaN ( ) noexcept
{ return static_cast < unsigned int > ( 0 ) ; }

static constexpr unsigned int
signaling_NaN ( ) noexcept
{ return static_cast < unsigned int > ( 0 ) ; }

static constexpr unsigned int
denorm_min ( ) noexcept
{ return static_cast < unsigned int > ( 0 ) ; }

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

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


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

static constexpr long
min ( ) noexcept { return - 9223372036854775807L - 1 ; }

static constexpr long
max ( ) noexcept { return 9223372036854775807L ; }


static constexpr long
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr long
epsilon ( ) noexcept { return 0 ; }

static constexpr long
round_error ( ) noexcept { return 0 ; }

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

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

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

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

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

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

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

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


template < >
struct numeric_limits < unsigned long >
{
static constexpr bool is_specialized = true ;

static constexpr unsigned long
min ( ) noexcept { return 0 ; }

static constexpr unsigned long
max ( ) noexcept { return 9223372036854775807L * 2UL + 1 ; }


static constexpr unsigned long
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr unsigned long
epsilon ( ) noexcept { return 0 ; }

static constexpr unsigned long
round_error ( ) noexcept { return 0 ; }

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

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

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

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

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

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

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

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


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

static constexpr long long
min ( ) noexcept { return - 9223372036854775807LL - 1 ; }

static constexpr long long
max ( ) noexcept { return 9223372036854775807LL ; }


static constexpr long long
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr long long
epsilon ( ) noexcept { return 0 ; }

static constexpr long long
round_error ( ) noexcept { return 0 ; }

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

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

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

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

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

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

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

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


template < >
struct numeric_limits < unsigned long long >
{
static constexpr bool is_specialized = true ;

static constexpr unsigned long long
min ( ) noexcept { return 0 ; }

static constexpr unsigned long long
max ( ) noexcept { return 9223372036854775807LL * 2ULL + 1 ; }


static constexpr unsigned long long
lowest ( ) noexcept { return min ( ) ; }


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

static constexpr int max_digits10 = 0 ;

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

static constexpr unsigned long long
epsilon ( ) noexcept { return 0 ; }

static constexpr unsigned long long
round_error ( ) noexcept { return 0 ; }

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

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

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

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

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

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

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

static constexpr bool traps = true ;
static constexpr bool tinyness_before = false ;
static constexpr float_round_style round_style
= round_toward_zero ;
} ;
#1552
template < >
struct numeric_limits < float >
{
static constexpr bool is_specialized = true ;

static constexpr float
min ( ) noexcept { return 1.17549435e-38F ; }

static constexpr float
max ( ) noexcept { return 3.40282347e+38F ; }


static constexpr float
lowest ( ) noexcept { return - 3.40282347e+38F ; }


static constexpr int digits = 24 ;
static constexpr int digits10 = 6 ;

static constexpr int max_digits10
= ( 2 + ( 24 ) * 643L / 2136 ) ;

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

static constexpr float
epsilon ( ) noexcept { return 1.19209290e-7F ; }

static constexpr float
round_error ( ) noexcept { return 0.5F ; }

static constexpr int min_exponent = ( - 125 ) ;
static constexpr int min_exponent10 = ( - 37 ) ;
static constexpr int max_exponent = 128 ;
static constexpr int max_exponent10 = 38 ;

static constexpr bool has_infinity = 1 ;
static constexpr bool has_quiet_NaN = 1 ;
static constexpr bool has_signaling_NaN = has_quiet_NaN ;
static constexpr float_denorm_style has_denorm
= bool ( 1 ) ? denorm_present : denorm_absent ;
static constexpr bool has_denorm_loss
= false ;

static constexpr float
infinity ( ) noexcept { return __builtin_huge_valf ( ) ; }

static constexpr float
quiet_NaN ( ) noexcept { return __builtin_nanf ( "" ) ; }

static constexpr float
signaling_NaN ( ) noexcept { return __builtin_nansf ( "" ) ; }

static constexpr float
denorm_min ( ) noexcept { return 1.40129846e-45F ; }

static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present ;
static constexpr bool is_bounded = true ;
static constexpr bool is_modulo = false ;

static constexpr bool traps = false ;
static constexpr bool tinyness_before
= false ;
static constexpr float_round_style round_style
= round_to_nearest ;
} ;
#1627
template < >
struct numeric_limits < double >
{
static constexpr bool is_specialized = true ;

static constexpr double
min ( ) noexcept { return 2.2250738585072014e-308 ; }

static constexpr double
max ( ) noexcept { return 1.7976931348623157e+308 ; }


static constexpr double
lowest ( ) noexcept { return - 1.7976931348623157e+308 ; }


static constexpr int digits = 53 ;
static constexpr int digits10 = 15 ;

static constexpr int max_digits10
= ( 2 + ( 53 ) * 643L / 2136 ) ;

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

static constexpr double
epsilon ( ) noexcept { return 2.2204460492503131e-16 ; }

static constexpr double
round_error ( ) noexcept { return 0.5 ; }

static constexpr int min_exponent = ( - 1021 ) ;
static constexpr int min_exponent10 = ( - 307 ) ;
static constexpr int max_exponent = 1024 ;
static constexpr int max_exponent10 = 308 ;

static constexpr bool has_infinity = 1 ;
static constexpr bool has_quiet_NaN = 1 ;
static constexpr bool has_signaling_NaN = has_quiet_NaN ;
static constexpr float_denorm_style has_denorm
= bool ( 1 ) ? denorm_present : denorm_absent ;
static constexpr bool has_denorm_loss
= false ;

static constexpr double
infinity ( ) noexcept { return __builtin_huge_val ( ) ; }

static constexpr double
quiet_NaN ( ) noexcept { return __builtin_nan ( "" ) ; }

static constexpr double
signaling_NaN ( ) noexcept { return __builtin_nans ( "" ) ; }

static constexpr double
denorm_min ( ) noexcept { return 4.9406564584124654e-324 ; }

static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present ;
static constexpr bool is_bounded = true ;
static constexpr bool is_modulo = false ;

static constexpr bool traps = false ;
static constexpr bool tinyness_before
= false ;
static constexpr float_round_style round_style
= round_to_nearest ;
} ;
#1702
template < >
struct numeric_limits < long double >
{
static constexpr bool is_specialized = true ;

static constexpr long double
min ( ) noexcept { return 3.36210314311209350626e-4932L ; }

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


static constexpr long double
lowest ( ) noexcept { return - 1.18973149535723176502e+4932L ; }


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

static constexpr int max_digits10
= ( 2 + ( 64 ) * 643L / 2136 ) ;

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

static constexpr long double
epsilon ( ) noexcept { return 1.08420217248550443401e-19L ; }

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

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

static constexpr bool has_infinity = 1 ;
static constexpr bool has_quiet_NaN = 1 ;
static constexpr bool has_signaling_NaN = has_quiet_NaN ;
static constexpr float_denorm_style has_denorm
= bool ( 1 ) ? denorm_present : denorm_absent ;
static constexpr bool has_denorm_loss
= false ;

static constexpr long double
infinity ( ) noexcept { return __builtin_huge_vall ( ) ; }

static constexpr long double
quiet_NaN ( ) noexcept { return __builtin_nanl ( "" ) ; }

static constexpr long double
signaling_NaN ( ) noexcept { return __builtin_nansl ( "" ) ; }

static constexpr long double
denorm_min ( ) noexcept { return 3.64519953188247460253e-4951L ; }

static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present ;
static constexpr bool is_bounded = true ;
static constexpr bool is_modulo = false ;

static constexpr bool traps = false ;
static constexpr bool tinyness_before =
false ;
static constexpr float_round_style round_style =
round_to_nearest ;
} ;
#1777
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/random.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/vector"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_uninitialized.h"
#59
namespace std
{


template < bool _TrivialValueTypes >
struct __uninitialized_copy
{
template < typename _InputIterator , typename _ForwardIterator >
static _ForwardIterator
__uninit_copy ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result )
{
_ForwardIterator __cur = __result ;
try
{
for ( ; __first != __last ; ++ __first , ++ __cur )
std :: _Construct ( std :: __addressof ( * __cur ) , * __first ) ;
return __cur ;
}
catch ( ... )
{
std :: _Destroy ( __result , __cur ) ;
throw ;
}
}
} ;

template < >
struct __uninitialized_copy < true >
{
template < typename _InputIterator , typename _ForwardIterator >
static _ForwardIterator
__uninit_copy ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result )
{ return std :: copy ( __first , __last , __result ) ; }
} ;
#105
template < typename _InputIterator , typename _ForwardIterator >
inline _ForwardIterator
uninitialized_copy ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result )
{
typedef typename iterator_traits < _InputIterator > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType2 ;

return std :: __uninitialized_copy < ( __oracle_is_trivial ( _ValueType1 )
&& __oracle_is_trivial ( _ValueType2 ) ) > ::
__uninit_copy ( __first , __last , __result ) ;
}


template < bool _TrivialValueType >
struct __uninitialized_fill
{
template < typename _ForwardIterator , typename _Tp >
static void
__uninit_fill ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __x )
{
_ForwardIterator __cur = __first ;
try
{
for ( ; __cur != __last ; ++ __cur )
std :: _Construct ( std :: __addressof ( * __cur ) , __x ) ;
}
catch ( ... )
{
std :: _Destroy ( __first , __cur ) ;
throw ;
}
}
} ;

template < >
struct __uninitialized_fill < true >
{
template < typename _ForwardIterator , typename _Tp >
static void
__uninit_fill ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __x )
{ std :: fill ( __first , __last , __x ) ; }
} ;
#162
template < typename _ForwardIterator , typename _Tp >
inline void
uninitialized_fill ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __x )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;

std :: __uninitialized_fill < __oracle_is_trivial ( _ValueType ) > ::
__uninit_fill ( __first , __last , __x ) ;
}


template < bool _TrivialValueType >
struct __uninitialized_fill_n
{
template < typename _ForwardIterator , typename _Size , typename _Tp >
static void
__uninit_fill_n ( _ForwardIterator __first , _Size __n ,
const _Tp & __x )
{
_ForwardIterator __cur = __first ;
try
{
for ( ; __n > 0 ; -- __n , ++ __cur )
std :: _Construct ( std :: __addressof ( * __cur ) , __x ) ;
}
catch ( ... )
{
std :: _Destroy ( __first , __cur ) ;
throw ;
}
}
} ;

template < >
struct __uninitialized_fill_n < true >
{
template < typename _ForwardIterator , typename _Size , typename _Tp >
static void
__uninit_fill_n ( _ForwardIterator __first , _Size __n ,
const _Tp & __x )
{ std :: fill_n ( __first , __n , __x ) ; }
} ;
#216
template < typename _ForwardIterator , typename _Size , typename _Tp >
inline void
uninitialized_fill_n ( _ForwardIterator __first , _Size __n , const _Tp & __x )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;

std :: __uninitialized_fill_n < __oracle_is_trivial ( _ValueType ) > ::
__uninit_fill_n ( __first , __n , __x ) ;
}
#233
template < typename _InputIterator , typename _ForwardIterator ,
typename _Allocator >
_ForwardIterator
__uninitialized_copy_a ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result , _Allocator & __alloc )
{
_ForwardIterator __cur = __result ;
try
{
typedef __gnu_cxx :: __alloc_traits < _Allocator > __traits ;
for ( ; __first != __last ; ++ __first , ++ __cur )
__traits :: construct ( __alloc , std :: __addressof ( * __cur ) , * __first ) ;
return __cur ;
}
catch ( ... )
{
std :: _Destroy ( __result , __cur , __alloc ) ;
throw ;
}
}

template < typename _InputIterator , typename _ForwardIterator , typename _Tp >
inline _ForwardIterator
__uninitialized_copy_a ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result , allocator < _Tp > & )
{ return std :: uninitialized_copy ( __first , __last , __result ) ; }

template < typename _InputIterator , typename _ForwardIterator ,
typename _Allocator >
inline _ForwardIterator
__uninitialized_move_a ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result , _Allocator & __alloc )
{
return std :: __uninitialized_copy_a ( std :: make_move_iterator ( __first ) ,
std :: make_move_iterator ( __last ) ,
__result , __alloc ) ;
}

template < typename _InputIterator , typename _ForwardIterator ,
typename _Allocator >
inline _ForwardIterator
__uninitialized_move_if_noexcept_a ( _InputIterator __first ,
_InputIterator __last ,
_ForwardIterator __result ,
_Allocator & __alloc )
{
return std :: __uninitialized_copy_a
( std :: __make_move_if_noexcept_iterator ( __first ) ,
std :: __make_move_if_noexcept_iterator ( __last ) , __result , __alloc ) ;
}

template < typename _ForwardIterator , typename _Tp , typename _Allocator >
void
__uninitialized_fill_a ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __x , _Allocator & __alloc )
{
_ForwardIterator __cur = __first ;
try
{
typedef __gnu_cxx :: __alloc_traits < _Allocator > __traits ;
for ( ; __cur != __last ; ++ __cur )
__traits :: construct ( __alloc , std :: __addressof ( * __cur ) , __x ) ;
}
catch ( ... )
{
std :: _Destroy ( __first , __cur , __alloc ) ;
throw ;
}
}

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

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

template < typename _ForwardIterator , typename _Size , typename _Tp ,
typename _Tp2 >
inline void
__uninitialized_fill_n_a ( _ForwardIterator __first , _Size __n ,
const _Tp & __x , allocator < _Tp2 > & )
{ std :: uninitialized_fill_n ( __first , __n , __x ) ; }
#346
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _ForwardIterator , typename _Allocator >
inline _ForwardIterator
__uninitialized_copy_move ( _InputIterator1 __first1 ,
_InputIterator1 __last1 ,
_InputIterator2 __first2 ,
_InputIterator2 __last2 ,
_ForwardIterator __result ,
_Allocator & __alloc )
{
_ForwardIterator __mid = std :: __uninitialized_copy_a ( __first1 , __last1 ,
__result ,
__alloc ) ;
try
{
return std :: __uninitialized_move_a ( __first2 , __last2 , __mid , __alloc ) ;
}
catch ( ... )
{
std :: _Destroy ( __result , __mid , __alloc ) ;
throw ;
}
}





template < typename _InputIterator1 , typename _InputIterator2 ,
typename _ForwardIterator , typename _Allocator >
inline _ForwardIterator
__uninitialized_move_copy ( _InputIterator1 __first1 ,
_InputIterator1 __last1 ,
_InputIterator2 __first2 ,
_InputIterator2 __last2 ,
_ForwardIterator __result ,
_Allocator & __alloc )
{
_ForwardIterator __mid = std :: __uninitialized_move_a ( __first1 , __last1 ,
__result ,
__alloc ) ;
try
{
return std :: __uninitialized_copy_a ( __first2 , __last2 , __mid , __alloc ) ;
}
catch ( ... )
{
std :: _Destroy ( __result , __mid , __alloc ) ;
throw ;
}
}




template < typename _ForwardIterator , typename _Tp , typename _InputIterator ,
typename _Allocator >
inline _ForwardIterator
__uninitialized_fill_move ( _ForwardIterator __result , _ForwardIterator __mid ,
const _Tp & __x , _InputIterator __first ,
_InputIterator __last , _Allocator & __alloc )
{
std :: __uninitialized_fill_a ( __result , __mid , __x , __alloc ) ;
try
{
return std :: __uninitialized_move_a ( __first , __last , __mid , __alloc ) ;
}
catch ( ... )
{
std :: _Destroy ( __result , __mid , __alloc ) ;
throw ;
}
}




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





template < bool _TrivialValueType >
struct __uninitialized_default_1
{
template < typename _ForwardIterator >
static void
__uninit_default ( _ForwardIterator __first , _ForwardIterator __last )
{
_ForwardIterator __cur = __first ;
try
{
for ( ; __cur != __last ; ++ __cur )
std :: _Construct ( std :: __addressof ( * __cur ) ) ;
}
catch ( ... )
{
std :: _Destroy ( __first , __cur ) ;
throw ;
}
}
} ;

template < >
struct __uninitialized_default_1 < true >
{
template < typename _ForwardIterator >
static void
__uninit_default ( _ForwardIterator __first , _ForwardIterator __last )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;

std :: fill ( __first , __last , _ValueType ( ) ) ;
}
} ;

template < bool _TrivialValueType >
struct __uninitialized_default_n_1
{
template < typename _ForwardIterator , typename _Size >
static void
__uninit_default_n ( _ForwardIterator __first , _Size __n )
{
_ForwardIterator __cur = __first ;
try
{
for ( ; __n > 0 ; -- __n , ++ __cur )
std :: _Construct ( std :: __addressof ( * __cur ) ) ;
}
catch ( ... )
{
std :: _Destroy ( __first , __cur ) ;
throw ;
}
}
} ;

template < >
struct __uninitialized_default_n_1 < true >
{
template < typename _ForwardIterator , typename _Size >
static void
__uninit_default_n ( _ForwardIterator __first , _Size __n )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;

std :: fill_n ( __first , __n , _ValueType ( ) ) ;
}
} ;




template < typename _ForwardIterator >
inline void
__uninitialized_default ( _ForwardIterator __first ,
_ForwardIterator __last )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;

std :: __uninitialized_default_1 < __oracle_is_trivial ( _ValueType ) > ::
__uninit_default ( __first , __last ) ;
}



template < typename _ForwardIterator , typename _Size >
inline void
__uninitialized_default_n ( _ForwardIterator __first , _Size __n )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;

std :: __uninitialized_default_n_1 < __oracle_is_trivial ( _ValueType ) > ::
__uninit_default_n ( __first , __n ) ;
}





template < typename _ForwardIterator , typename _Allocator >
void
__uninitialized_default_a ( _ForwardIterator __first ,
_ForwardIterator __last ,
_Allocator & __alloc )
{
_ForwardIterator __cur = __first ;
try
{
typedef __gnu_cxx :: __alloc_traits < _Allocator > __traits ;
for ( ; __cur != __last ; ++ __cur )
__traits :: construct ( __alloc , std :: __addressof ( * __cur ) ) ;
}
catch ( ... )
{
std :: _Destroy ( __first , __cur , __alloc ) ;
throw ;
}
}

template < typename _ForwardIterator , typename _Tp >
inline void
__uninitialized_default_a ( _ForwardIterator __first ,
_ForwardIterator __last ,
allocator < _Tp > & )
{ std :: __uninitialized_default ( __first , __last ) ; }





template < typename _ForwardIterator , typename _Size , typename _Allocator >
void
__uninitialized_default_n_a ( _ForwardIterator __first , _Size __n ,
_Allocator & __alloc )
{
_ForwardIterator __cur = __first ;
try
{
typedef __gnu_cxx :: __alloc_traits < _Allocator > __traits ;
for ( ; __n > 0 ; -- __n , ++ __cur )
__traits :: construct ( __alloc , std :: __addressof ( * __cur ) ) ;
}
catch ( ... )
{
std :: _Destroy ( __first , __cur , __alloc ) ;
throw ;
}
}

template < typename _ForwardIterator , typename _Size , typename _Tp >
inline void
__uninitialized_default_n_a ( _ForwardIterator __first , _Size __n ,
allocator < _Tp > & )
{ std :: __uninitialized_default_n ( __first , __n ) ; }


template < typename _InputIterator , typename _Size ,
typename _ForwardIterator >
_ForwardIterator
__uninitialized_copy_n ( _InputIterator __first , _Size __n ,
_ForwardIterator __result , input_iterator_tag )
{
_ForwardIterator __cur = __result ;
try
{
for ( ; __n > 0 ; -- __n , ++ __first , ++ __cur )
std :: _Construct ( std :: __addressof ( * __cur ) , * __first ) ;
return __cur ;
}
catch ( ... )
{
std :: _Destroy ( __result , __cur ) ;
throw ;
}
}

template < typename _RandomAccessIterator , typename _Size ,
typename _ForwardIterator >
inline _ForwardIterator
__uninitialized_copy_n ( _RandomAccessIterator __first , _Size __n ,
_ForwardIterator __result ,
random_access_iterator_tag )
{ return std :: uninitialized_copy ( __first , __first + __n , __result ) ; }
#645
template < typename _InputIterator , typename _Size , typename _ForwardIterator >
inline _ForwardIterator
uninitialized_copy_n ( _InputIterator __first , _Size __n ,
_ForwardIterator __result )
{ return std :: __uninitialized_copy_n ( __first , __n , __result ,
std :: __iterator_category ( __first ) ) ; }



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_vector.h"
#66
namespace std
{



template < typename _Tp , typename _Alloc >
struct _Vector_base
{
typedef typename __gnu_cxx :: __alloc_traits < _Alloc > :: template
rebind < _Tp > :: other _Tp_alloc_type ;
typedef typename __gnu_cxx :: __alloc_traits < _Tp_alloc_type > :: pointer
pointer ;

struct _Vector_impl
: public _Tp_alloc_type
{
pointer _M_start ;
pointer _M_finish ;
pointer _M_end_of_storage ;

_Vector_impl ( )
: _Tp_alloc_type ( ) , _M_start ( 0 ) , _M_finish ( 0 ) , _M_end_of_storage ( 0 )
{ }

_Vector_impl ( _Tp_alloc_type const & __a )
: _Tp_alloc_type ( __a ) , _M_start ( 0 ) , _M_finish ( 0 ) , _M_end_of_storage ( 0 )
{ }


_Vector_impl ( _Tp_alloc_type && __a )
: _Tp_alloc_type ( std :: move ( __a ) ) ,
_M_start ( 0 ) , _M_finish ( 0 ) , _M_end_of_storage ( 0 )
{ }


void _M_swap_data ( _Vector_impl & __x )
{
std :: swap ( _M_start , __x . _M_start ) ;
std :: swap ( _M_finish , __x . _M_finish ) ;
std :: swap ( _M_end_of_storage , __x . _M_end_of_storage ) ;
}
} ;

public :
typedef _Alloc allocator_type ;

_Tp_alloc_type &
_M_get_Tp_allocator ( ) noexcept
{ return * static_cast < _Tp_alloc_type * > ( & this -> _M_impl ) ; }

const _Tp_alloc_type &
_M_get_Tp_allocator ( ) const noexcept
{ return * static_cast < const _Tp_alloc_type * > ( & this -> _M_impl ) ; }

allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_get_Tp_allocator ( ) ) ; }

_Vector_base ( )
: _M_impl ( ) { }

_Vector_base ( const allocator_type & __a )
: _M_impl ( __a ) { }

_Vector_base ( size_t __n )
: _M_impl ( )
{ _M_create_storage ( __n ) ; }

_Vector_base ( size_t __n , const allocator_type & __a )
: _M_impl ( __a )
{ _M_create_storage ( __n ) ; }


_Vector_base ( _Tp_alloc_type && __a )
: _M_impl ( std :: move ( __a ) ) { }

_Vector_base ( _Vector_base && __x )
: _M_impl ( std :: move ( __x . _M_get_Tp_allocator ( ) ) )
{ this -> _M_impl . _M_swap_data ( __x . _M_impl ) ; }

_Vector_base ( _Vector_base && __x , const allocator_type & __a )
: _M_impl ( __a )
{
if ( __x . get_allocator ( ) == __a )
this -> _M_impl . _M_swap_data ( __x . _M_impl ) ;
else
{
size_t __n = __x . _M_impl . _M_finish - __x . _M_impl . _M_start ;
_M_create_storage ( __n ) ;
}
}


~ _Vector_base ( )
{ _M_deallocate ( this -> _M_impl . _M_start , this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ; }

public :
_Vector_impl _M_impl ;

pointer
_M_allocate ( size_t __n )
{ return __n != 0 ? _M_impl . allocate ( __n ) : 0 ; }

void
_M_deallocate ( pointer __p , size_t __n )
{
if ( __p )
_M_impl . deallocate ( __p , __n ) ;
}

private :
void
_M_create_storage ( size_t __n )
{
this -> _M_impl . _M_start = this -> _M_allocate ( __n ) ;
this -> _M_impl . _M_finish = this -> _M_impl . _M_start ;
this -> _M_impl . _M_end_of_storage = this -> _M_impl . _M_start + __n ;
}
} ;
#209
template < typename _Tp , typename _Alloc = std :: allocator < _Tp > >
class vector : protected _Vector_base < _Tp , _Alloc >
{

typedef typename _Alloc :: value_type _Alloc_value_type ;



typedef _Vector_base < _Tp , _Alloc > _Base ;
typedef typename _Base :: _Tp_alloc_type _Tp_alloc_type ;
typedef __gnu_cxx :: __alloc_traits < _Tp_alloc_type > _Alloc_traits ;

public :
typedef _Tp value_type ;
typedef typename _Base :: pointer pointer ;
typedef typename _Alloc_traits :: const_pointer const_pointer ;
typedef typename _Alloc_traits :: reference reference ;
typedef typename _Alloc_traits :: const_reference const_reference ;
typedef __gnu_cxx :: __normal_iterator < pointer , vector > iterator ;
typedef __gnu_cxx :: __normal_iterator < const_pointer , vector >
const_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;
typedef std :: reverse_iterator < iterator > reverse_iterator ;
typedef size_t size_type ;
typedef ptrdiff_t difference_type ;
typedef _Alloc allocator_type ;

protected :
using _Base :: _M_allocate ;
using _Base :: _M_deallocate ;
using _Base :: _M_impl ;
using _Base :: _M_get_Tp_allocator ;

public :





vector ( )
: _Base ( ) { }





explicit
vector ( const allocator_type & __a )
: _Base ( __a ) { }
#268
explicit
vector ( size_type __n , const allocator_type & __a = allocator_type ( ) )
: _Base ( __n , __a )
{ _M_default_initialize ( __n ) ; }
#281
vector ( size_type __n , const value_type & __value ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __n , __a )
{ _M_fill_initialize ( __n , __value ) ; }
#310
vector ( const vector & __x )
: _Base ( __x . size ( ) ,
_Alloc_traits :: _S_select_on_copy ( __x . _M_get_Tp_allocator ( ) ) )
{ this -> _M_impl . _M_finish =
std :: __uninitialized_copy_a ( __x . begin ( ) , __x . end ( ) ,
this -> _M_impl . _M_start ,
_M_get_Tp_allocator ( ) ) ;
}
#327
vector ( vector && __x ) noexcept
: _Base ( std :: move ( __x ) ) { }


vector ( const vector & __x , const allocator_type & __a )
: _Base ( __x . size ( ) , __a )
{ this -> _M_impl . _M_finish =
std :: __uninitialized_copy_a ( __x . begin ( ) , __x . end ( ) ,
this -> _M_impl . _M_start ,
_M_get_Tp_allocator ( ) ) ;
}


vector ( vector && __rv , const allocator_type & __m )
: _Base ( std :: move ( __rv ) , __m )
{
if ( __rv . get_allocator ( ) != __m )
{
this -> _M_impl . _M_finish =
std :: __uninitialized_move_a ( __rv . begin ( ) , __rv . end ( ) ,
this -> _M_impl . _M_start ,
_M_get_Tp_allocator ( ) ) ;
__rv . clear ( ) ;
}
}
#364
vector ( initializer_list < value_type > __l ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a )
{
_M_range_initialize ( __l . begin ( ) , __l . end ( ) ,
random_access_iterator_tag ( ) ) ;
}
#390
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
vector ( _InputIterator __first , _InputIterator __last ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a )
{ _M_initialize_dispatch ( __first , __last , __false_type ( ) ) ; }
#414
~ vector ( ) noexcept
{ std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ; }
#426
vector &
operator = ( const vector & __x ) ;
#438
vector &
operator = ( vector && __x ) noexcept ( _Alloc_traits :: _S_nothrow_move ( ) )
{
constexpr bool __move_storage =
_Alloc_traits :: _S_propagate_on_move_assign ( )
|| _Alloc_traits :: _S_always_equal ( ) ;
_M_move_assign ( std :: move ( __x ) ,
integral_constant < bool , __move_storage > ( ) ) ;
return * this ;
}
#460
vector &
operator = ( initializer_list < value_type > __l )
{
this -> assign ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}
#478
void
assign ( size_type __n , const value_type & __val )
{ _M_fill_assign ( __n , __val ) ; }
#495
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
void
assign ( _InputIterator __first , _InputIterator __last )
{ _M_assign_dispatch ( __first , __last , __false_type ( ) ) ; }
#523
void
assign ( initializer_list < value_type > __l )
{ this -> assign ( __l . begin ( ) , __l . end ( ) ) ; }



using _Base :: get_allocator ;
#537
iterator
begin ( ) noexcept
{ return iterator ( this -> _M_impl . _M_start ) ; }
#546
const_iterator
begin ( ) const noexcept
{ return const_iterator ( this -> _M_impl . _M_start ) ; }
#555
iterator
end ( ) noexcept
{ return iterator ( this -> _M_impl . _M_finish ) ; }
#564
const_iterator
end ( ) const noexcept
{ return const_iterator ( this -> _M_impl . _M_finish ) ; }
#573
reverse_iterator
rbegin ( ) noexcept
{ return reverse_iterator ( end ( ) ) ; }
#582
const_reverse_iterator
rbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }
#591
reverse_iterator
rend ( ) noexcept
{ return reverse_iterator ( begin ( ) ) ; }
#600
const_reverse_iterator
rend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }
#610
const_iterator
cbegin ( ) const noexcept
{ return const_iterator ( this -> _M_impl . _M_start ) ; }
#619
const_iterator
cend ( ) const noexcept
{ return const_iterator ( this -> _M_impl . _M_finish ) ; }
#628
const_reverse_iterator
crbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }
#637
const_reverse_iterator
crend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }




size_type
size ( ) const noexcept
{ return size_type ( this -> _M_impl . _M_finish - this -> _M_impl . _M_start ) ; }


size_type
max_size ( ) const noexcept
{ return _Alloc_traits :: max_size ( _M_get_Tp_allocator ( ) ) ; }
#663
void
resize ( size_type __new_size )
{
if ( __new_size > size ( ) )
_M_default_append ( __new_size - size ( ) ) ;
else if ( __new_size < size ( ) )
_M_erase_at_end ( this -> _M_impl . _M_start + __new_size ) ;
}
#683
void
resize ( size_type __new_size , const value_type & __x )
{
if ( __new_size > size ( ) )
insert ( end ( ) , __new_size - size ( ) , __x ) ;
else if ( __new_size < size ( ) )
_M_erase_at_end ( this -> _M_impl . _M_start + __new_size ) ;
}
#715
void
shrink_to_fit ( )
{ _M_shrink_to_fit ( ) ; }
#724
size_type
capacity ( ) const noexcept
{ return size_type ( this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ; }





bool
empty ( ) const noexcept
{ return begin ( ) == end ( ) ; }
#754
void
reserve ( size_type __n ) ;
#769
reference
operator [ ] ( size_type __n )
{ return * ( this -> _M_impl . _M_start + __n ) ; }
#784
const_reference
operator [ ] ( size_type __n ) const
{ return * ( this -> _M_impl . _M_start + __n ) ; }

protected :

void
_M_range_check ( size_type __n ) const
{
if ( __n >= this -> size ( ) )
__throw_out_of_range ( ( "vector::_M_range_check" ) ) ;
}

public :
#809
reference
at ( size_type __n )
{
_M_range_check ( __n ) ;
return ( * this ) [ __n ] ;
}
#827
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 ) ; }
#874
_Tp *



data ( ) noexcept
{ return std :: __addressof ( front ( ) ) ; }


const _Tp *



data ( ) const noexcept
{ return std :: __addressof ( front ( ) ) ; }
#900
void
push_back ( const value_type & __x )
{
if ( this -> _M_impl . _M_finish != this -> _M_impl . _M_end_of_storage )
{
_Alloc_traits :: construct ( this -> _M_impl , this -> _M_impl . _M_finish ,
__x ) ;
++ this -> _M_impl . _M_finish ;
}
else

_M_emplace_back_aux ( __x ) ;



}


void
push_back ( value_type && __x )
{ emplace_back ( std :: move ( __x ) ) ; }

template < typename ... _Args >
void
emplace_back ( _Args && ... __args ) ;
#936
void
pop_back ( )
{
-- this -> _M_impl . _M_finish ;
_Alloc_traits :: destroy ( this -> _M_impl , this -> _M_impl . _M_finish ) ;
}
#956
template < typename ... _Args >
iterator
emplace ( iterator __position , _Args && ... __args ) ;
#972
iterator
insert ( iterator __position , const value_type & __x ) ;
#987
iterator
insert ( iterator __position , value_type && __x )
{ return emplace ( __position , std :: move ( __x ) ) ; }
#1004
void
insert ( iterator __position , initializer_list < value_type > __l )
{ this -> insert ( __position , __l . begin ( ) , __l . end ( ) ) ; }
#1022
void
insert ( iterator __position , size_type __n , const value_type & __x )
{ _M_fill_insert ( __position , __n , __x ) ; }
#1041
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
void
insert ( iterator __position , _InputIterator __first ,
_InputIterator __last )
{ _M_insert_dispatch ( __position , __first , __last , __false_type ( ) ) ; }
#1074
iterator
erase ( iterator __position ) ;
#1095
iterator
erase ( iterator __first , iterator __last ) ;
#1107
void
swap ( vector & __x )

noexcept ( _Alloc_traits :: _S_nothrow_swap ( ) )

{
this -> _M_impl . _M_swap_data ( __x . _M_impl ) ;
_Alloc_traits :: _S_on_swap ( _M_get_Tp_allocator ( ) ,
__x . _M_get_Tp_allocator ( ) ) ;
}
#1124
void
clear ( ) noexcept
{ _M_erase_at_end ( this -> _M_impl . _M_start ) ; }

protected :




template < typename _ForwardIterator >
pointer
_M_allocate_and_copy ( size_type __n ,
_ForwardIterator __first , _ForwardIterator __last )
{
pointer __result = this -> _M_allocate ( __n ) ;
try
{
std :: __uninitialized_copy_a ( __first , __last , __result ,
_M_get_Tp_allocator ( ) ) ;
return __result ;
}
catch ( ... )
{
_M_deallocate ( __result , __n ) ;
throw ;
}
}
#1159
template < typename _Integer >
void
_M_initialize_dispatch ( _Integer __n , _Integer __value , __true_type )
{
this -> _M_impl . _M_start = _M_allocate ( static_cast < size_type > ( __n ) ) ;
this -> _M_impl . _M_end_of_storage =
this -> _M_impl . _M_start + static_cast < size_type > ( __n ) ;
_M_fill_initialize ( static_cast < size_type > ( __n ) , __value ) ;
}


template < typename _InputIterator >
void
_M_initialize_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type )
{
typedef typename std :: iterator_traits < _InputIterator > ::
iterator_category _IterCategory ;
_M_range_initialize ( __first , __last , _IterCategory ( ) ) ;
}


template < typename _InputIterator >
void
_M_range_initialize ( _InputIterator __first ,
_InputIterator __last , std :: input_iterator_tag )
{
for ( ; __first != __last ; ++ __first )

emplace_back ( * __first ) ;



}


template < typename _ForwardIterator >
void
_M_range_initialize ( _ForwardIterator __first ,
_ForwardIterator __last , std :: forward_iterator_tag )
{
const size_type __n = std :: distance ( __first , __last ) ;
this -> _M_impl . _M_start = this -> _M_allocate ( __n ) ;
this -> _M_impl . _M_end_of_storage = this -> _M_impl . _M_start + __n ;
this -> _M_impl . _M_finish =
std :: __uninitialized_copy_a ( __first , __last ,
this -> _M_impl . _M_start ,
_M_get_Tp_allocator ( ) ) ;
}



void
_M_fill_initialize ( size_type __n , const value_type & __value )
{
std :: __uninitialized_fill_n_a ( this -> _M_impl . _M_start , __n , __value ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = this -> _M_impl . _M_end_of_storage ;
}



void
_M_default_initialize ( size_type __n )
{
std :: __uninitialized_default_n_a ( this -> _M_impl . _M_start , __n ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = this -> _M_impl . _M_end_of_storage ;
}
#1237
template < typename _Integer >
void
_M_assign_dispatch ( _Integer __n , _Integer __val , __true_type )
{ _M_fill_assign ( __n , __val ) ; }


template < typename _InputIterator >
void
_M_assign_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type )
{
typedef typename std :: iterator_traits < _InputIterator > ::
iterator_category _IterCategory ;
_M_assign_aux ( __first , __last , _IterCategory ( ) ) ;
}


template < typename _InputIterator >
void
_M_assign_aux ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag ) ;


template < typename _ForwardIterator >
void
_M_assign_aux ( _ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag ) ;



void
_M_fill_assign ( size_type __n , const value_type & __val ) ;
#1277
template < typename _Integer >
void
_M_insert_dispatch ( iterator __pos , _Integer __n , _Integer __val ,
__true_type )
{ _M_fill_insert ( __pos , __n , __val ) ; }


template < typename _InputIterator >
void
_M_insert_dispatch ( iterator __pos , _InputIterator __first ,
_InputIterator __last , __false_type )
{
typedef typename std :: iterator_traits < _InputIterator > ::
iterator_category _IterCategory ;
_M_range_insert ( __pos , __first , __last , _IterCategory ( ) ) ;
}


template < typename _InputIterator >
void
_M_range_insert ( iterator __pos , _InputIterator __first ,
_InputIterator __last , std :: input_iterator_tag ) ;


template < typename _ForwardIterator >
void
_M_range_insert ( iterator __pos , _ForwardIterator __first ,
_ForwardIterator __last , std :: forward_iterator_tag ) ;



void
_M_fill_insert ( iterator __pos , size_type __n , const value_type & __x ) ;



void
_M_default_append ( size_type __n ) ;

bool
_M_shrink_to_fit ( ) ;
#1325
template < typename ... _Args >
void
_M_insert_aux ( iterator __position , _Args && ... __args ) ;

template < typename ... _Args >
void
_M_emplace_back_aux ( _Args && ... __args ) ;



size_type
_M_check_len ( size_type __n , const char * __s ) const
{
if ( max_size ( ) - size ( ) < __n )
__throw_length_error ( ( __s ) ) ;

const size_type __len = size ( ) + std :: max ( size ( ) , __n ) ;
return ( __len < size ( ) || __len > max_size ( ) ) ? max_size ( ) : __len ;
}





void
_M_erase_at_end ( pointer __pos )
{
std :: _Destroy ( __pos , this -> _M_impl . _M_finish , _M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __pos ;
}


private :



void
_M_move_assign ( vector && __x , std :: true_type ) noexcept
{
const vector __tmp ( std :: move ( * this ) ) ;
this -> _M_impl . _M_swap_data ( __x . _M_impl ) ;
if ( _Alloc_traits :: _S_propagate_on_move_assign ( ) )
std :: __alloc_on_move ( _M_get_Tp_allocator ( ) ,
__x . _M_get_Tp_allocator ( ) ) ;
}



void
_M_move_assign ( vector && __x , std :: false_type )
{
if ( __x . _M_get_Tp_allocator ( ) == this -> _M_get_Tp_allocator ( ) )
_M_move_assign ( std :: move ( __x ) , std :: true_type ( ) ) ;
else
{


this -> assign ( std :: __make_move_if_noexcept_iterator ( __x . begin ( ) ) ,
std :: __make_move_if_noexcept_iterator ( __x . end ( ) ) ) ;
__x . clear ( ) ;
}
}

} ;
#1401
template < typename _Tp , typename _Alloc >
inline bool
operator == ( const vector < _Tp , _Alloc > & __x , const vector < _Tp , _Alloc > & __y )
{ return ( __x . size ( ) == __y . size ( )
&& std :: equal ( __x . begin ( ) , __x . end ( ) , __y . begin ( ) ) ) ; }
#1418
template < typename _Tp , typename _Alloc >
inline bool
operator < ( const vector < _Tp , _Alloc > & __x , const vector < _Tp , _Alloc > & __y )
{ return std :: lexicographical_compare ( __x . begin ( ) , __x . end ( ) ,
__y . begin ( ) , __y . end ( ) ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator != ( const vector < _Tp , _Alloc > & __x , const vector < _Tp , _Alloc > & __y )
{ return ! ( __x == __y ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator > ( const vector < _Tp , _Alloc > & __x , const vector < _Tp , _Alloc > & __y )
{ return __y < __x ; }


template < typename _Tp , typename _Alloc >
inline bool
operator <= ( const vector < _Tp , _Alloc > & __x , const vector < _Tp , _Alloc > & __y )
{ return ! ( __y < __x ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator >= ( const vector < _Tp , _Alloc > & __x , const vector < _Tp , _Alloc > & __y )
{ return ! ( __x < __y ) ; }


template < typename _Tp , typename _Alloc >
inline void
swap ( vector < _Tp , _Alloc > & __x , vector < _Tp , _Alloc > & __y )
{ __x . swap ( __y ) ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_bvector.h"
#63
namespace std
{


typedef unsigned long _Bit_type ;
enum { _S_word_bit = int ( 8 * sizeof ( _Bit_type ) ) } ;

struct _Bit_reference
{
_Bit_type * _M_p ;
_Bit_type _M_mask ;

_Bit_reference ( _Bit_type * __x , _Bit_type __y )
: _M_p ( __x ) , _M_mask ( __y ) { }

_Bit_reference ( ) noexcept : _M_p ( 0 ) , _M_mask ( 0 ) { }

operator bool ( ) const noexcept
{ return ! ! ( * _M_p & _M_mask ) ; }

_Bit_reference &
operator = ( bool __x ) noexcept
{
if ( __x )
* _M_p |= _M_mask ;
else
* _M_p &= ~ _M_mask ;
return * this ;
}

_Bit_reference &
operator = ( const _Bit_reference & __x ) noexcept
{ 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 ( ) noexcept
{ * _M_p ^= _M_mask ; }
} ;


inline void
swap ( _Bit_reference __x , _Bit_reference __y ) noexcept
{
bool __tmp = __x ;
__x = __y ;
__y = __tmp ;
}

inline void
swap ( _Bit_reference __x , bool & __y ) noexcept
{
bool __tmp = __x ;
__x = __y ;
__y = __tmp ;
}

inline void
swap ( bool & __x , _Bit_reference __y ) noexcept
{
bool __tmp = __x ;
__x = __y ;
__y = __tmp ;
}


struct _Bit_iterator_base
: public std :: iterator < std :: random_access_iterator_tag , bool >
{
_Bit_type * _M_p ;
unsigned int _M_offset ;

_Bit_iterator_base ( _Bit_type * __x , unsigned int __y )
: _M_p ( __x ) , _M_offset ( __y ) { }

void
_M_bump_up ( )
{
if ( _M_offset ++ == int ( _S_word_bit ) - 1 )
{
_M_offset = 0 ;
++ _M_p ;
}
}

void
_M_bump_down ( )
{
if ( _M_offset -- == 0 )
{
_M_offset = int ( _S_word_bit ) - 1 ;
-- _M_p ;
}
}

void
_M_incr ( ptrdiff_t __i )
{
difference_type __n = __i + _M_offset ;
_M_p += __n / int ( _S_word_bit ) ;
__n = __n % int ( _S_word_bit ) ;
if ( __n < 0 )
{
__n += int ( _S_word_bit ) ;
-- _M_p ;
}
_M_offset = static_cast < unsigned int > ( __n ) ;
}

bool
operator == ( const _Bit_iterator_base & __i ) const
{ return _M_p == __i . _M_p && _M_offset == __i . _M_offset ; }

bool
operator < ( const _Bit_iterator_base & __i ) const
{
return _M_p < __i . _M_p
|| ( _M_p == __i . _M_p && _M_offset < __i . _M_offset ) ;
}

bool
operator != ( const _Bit_iterator_base & __i ) const
{ return ! ( * this == __i ) ; }

bool
operator > ( const _Bit_iterator_base & __i ) const
{ return __i < * this ; }

bool
operator <= ( const _Bit_iterator_base & __i ) const
{ return ! ( __i < * this ) ; }

bool
operator >= ( const _Bit_iterator_base & __i ) const
{ return ! ( * this < __i ) ; }
} ;

inline ptrdiff_t
operator - ( const _Bit_iterator_base & __x , const _Bit_iterator_base & __y )
{
return ( int ( _S_word_bit ) * ( __x . _M_p - __y . _M_p )
+ __x . _M_offset - __y . _M_offset ) ;
}

struct _Bit_iterator : public _Bit_iterator_base
{
typedef _Bit_reference reference ;
typedef _Bit_reference * pointer ;
typedef _Bit_iterator iterator ;

_Bit_iterator ( ) : _Bit_iterator_base ( 0 , 0 ) { }

_Bit_iterator ( _Bit_type * __x , unsigned int __y )
: _Bit_iterator_base ( __x , __y ) { }

reference
operator * ( ) const
{ return reference ( _M_p , 1UL << _M_offset ) ; }

iterator &
operator ++ ( )
{
_M_bump_up ( ) ;
return * this ;
}

iterator
operator ++ ( int )
{
iterator __tmp = * this ;
_M_bump_up ( ) ;
return __tmp ;
}

iterator &
operator -- ( )
{
_M_bump_down ( ) ;
return * this ;
}

iterator
operator -- ( int )
{
iterator __tmp = * this ;
_M_bump_down ( ) ;
return __tmp ;
}

iterator &
operator += ( difference_type __i )
{
_M_incr ( __i ) ;
return * this ;
}

iterator &
operator -= ( difference_type __i )
{
* this += - __i ;
return * this ;
}

iterator
operator + ( difference_type __i ) const
{
iterator __tmp = * this ;
return __tmp += __i ;
}

iterator
operator - ( difference_type __i ) const
{
iterator __tmp = * this ;
return __tmp -= __i ;
}

reference
operator [ ] ( difference_type __i ) const
{ return * ( * this + __i ) ; }
} ;

inline _Bit_iterator
operator + ( ptrdiff_t __n , const _Bit_iterator & __x )
{ return __x + __n ; }

struct _Bit_const_iterator : public _Bit_iterator_base
{
typedef bool reference ;
typedef bool const_reference ;
typedef const bool * pointer ;
typedef _Bit_const_iterator const_iterator ;

_Bit_const_iterator ( ) : _Bit_iterator_base ( 0 , 0 ) { }

_Bit_const_iterator ( _Bit_type * __x , unsigned int __y )
: _Bit_iterator_base ( __x , __y ) { }

_Bit_const_iterator ( const _Bit_iterator & __x )
: _Bit_iterator_base ( __x . _M_p , __x . _M_offset ) { }

const_reference
operator * ( ) const
{ return _Bit_reference ( _M_p , 1UL << _M_offset ) ; }

const_iterator &
operator ++ ( )
{
_M_bump_up ( ) ;
return * this ;
}

const_iterator
operator ++ ( int )
{
const_iterator __tmp = * this ;
_M_bump_up ( ) ;
return __tmp ;
}

const_iterator &
operator -- ( )
{
_M_bump_down ( ) ;
return * this ;
}

const_iterator
operator -- ( int )
{
const_iterator __tmp = * this ;
_M_bump_down ( ) ;
return __tmp ;
}

const_iterator &
operator += ( difference_type __i )
{
_M_incr ( __i ) ;
return * this ;
}

const_iterator &
operator -= ( difference_type __i )
{
* this += - __i ;
return * this ;
}

const_iterator
operator + ( difference_type __i ) const
{
const_iterator __tmp = * this ;
return __tmp += __i ;
}

const_iterator
operator - ( difference_type __i ) const
{
const_iterator __tmp = * this ;
return __tmp -= __i ;
}

const_reference
operator [ ] ( difference_type __i ) const
{ return * ( * this + __i ) ; }
} ;

inline _Bit_const_iterator
operator + ( ptrdiff_t __n , const _Bit_const_iterator & __x )
{ return __x + __n ; }

inline void
__fill_bvector ( _Bit_iterator __first , _Bit_iterator __last , bool __x )
{
for ( ; __first != __last ; ++ __first )
* __first = __x ;
}

inline void
fill ( _Bit_iterator __first , _Bit_iterator __last , const bool & __x )
{
if ( __first . _M_p != __last . _M_p )
{
std :: fill ( __first . _M_p + 1 , __last . _M_p , __x ? ~ 0 : 0 ) ;
__fill_bvector ( __first , _Bit_iterator ( __first . _M_p + 1 , 0 ) , __x ) ;
__fill_bvector ( _Bit_iterator ( __last . _M_p , 0 ) , __last , __x ) ;
}
else
__fill_bvector ( __first , __last , __x ) ;
}

template < typename _Alloc >
struct _Bvector_base
{
typedef typename _Alloc :: template rebind < _Bit_type > :: other
_Bit_alloc_type ;

struct _Bvector_impl
: public _Bit_alloc_type
{
_Bit_iterator _M_start ;
_Bit_iterator _M_finish ;
_Bit_type * _M_end_of_storage ;

_Bvector_impl ( )
: _Bit_alloc_type ( ) , _M_start ( ) , _M_finish ( ) , _M_end_of_storage ( 0 )
{ }

_Bvector_impl ( const _Bit_alloc_type & __a )
: _Bit_alloc_type ( __a ) , _M_start ( ) , _M_finish ( ) , _M_end_of_storage ( 0 )
{ }


_Bvector_impl ( _Bit_alloc_type && __a )
: _Bit_alloc_type ( std :: move ( __a ) ) , _M_start ( ) , _M_finish ( ) ,
_M_end_of_storage ( 0 )
{ }

} ;

public :
typedef _Alloc allocator_type ;

_Bit_alloc_type &
_M_get_Bit_allocator ( ) noexcept
{ return * static_cast < _Bit_alloc_type * > ( & this -> _M_impl ) ; }

const _Bit_alloc_type &
_M_get_Bit_allocator ( ) const noexcept
{ return * static_cast < const _Bit_alloc_type * > ( & this -> _M_impl ) ; }

allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_get_Bit_allocator ( ) ) ; }

_Bvector_base ( )
: _M_impl ( ) { }

_Bvector_base ( const allocator_type & __a )
: _M_impl ( __a ) { }


_Bvector_base ( _Bvector_base && __x ) noexcept
: _M_impl ( std :: move ( __x . _M_get_Bit_allocator ( ) ) )
{
this -> _M_impl . _M_start = __x . _M_impl . _M_start ;
this -> _M_impl . _M_finish = __x . _M_impl . _M_finish ;
this -> _M_impl . _M_end_of_storage = __x . _M_impl . _M_end_of_storage ;
__x . _M_impl . _M_start = _Bit_iterator ( ) ;
__x . _M_impl . _M_finish = _Bit_iterator ( ) ;
__x . _M_impl . _M_end_of_storage = 0 ;
}


~ _Bvector_base ( )
{ this -> _M_deallocate ( ) ; }

protected :
_Bvector_impl _M_impl ;

_Bit_type *
_M_allocate ( size_t __n )
{ return _M_impl . allocate ( _S_nword ( __n ) ) ; }

void
_M_deallocate ( )
{
if ( _M_impl . _M_start . _M_p )
_M_impl . deallocate ( _M_impl . _M_start . _M_p ,
_M_impl . _M_end_of_storage - _M_impl . _M_start . _M_p ) ;
}

static size_t
_S_nword ( size_t __n )
{ return ( __n + int ( _S_word_bit ) - 1 ) / int ( _S_word_bit ) ; }
} ;


}
#494
namespace std
{
#517
template < typename _Alloc >
class vector < bool , _Alloc > : protected _Bvector_base < _Alloc >
{
typedef _Bvector_base < _Alloc > _Base ;


template < typename > friend struct hash ;


public :
typedef bool value_type ;
typedef size_t size_type ;
typedef ptrdiff_t difference_type ;
typedef _Bit_reference reference ;
typedef bool const_reference ;
typedef _Bit_reference * pointer ;
typedef const bool * const_pointer ;
typedef _Bit_iterator iterator ;
typedef _Bit_const_iterator const_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;
typedef std :: reverse_iterator < iterator > reverse_iterator ;
typedef _Alloc allocator_type ;

allocator_type get_allocator ( ) const
{ return _Base :: get_allocator ( ) ; }

protected :
using _Base :: _M_allocate ;
using _Base :: _M_deallocate ;
using _Base :: _S_nword ;
using _Base :: _M_get_Bit_allocator ;

public :
vector ( )
: _Base ( ) { }

explicit
vector ( const allocator_type & __a )
: _Base ( __a ) { }


explicit
vector ( size_type __n , const allocator_type & __a = allocator_type ( ) )
: vector ( __n , false , __a )
{ }

vector ( size_type __n , const bool & __value ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a )
{
_M_initialize ( __n ) ;
std :: fill ( this -> _M_impl . _M_start . _M_p , this -> _M_impl . _M_end_of_storage ,
__value ? ~ 0 : 0 ) ;
}
#583
vector ( const vector & __x )
: _Base ( __x . _M_get_Bit_allocator ( ) )
{
_M_initialize ( __x . size ( ) ) ;
_M_copy_aligned ( __x . begin ( ) , __x . end ( ) , this -> _M_impl . _M_start ) ;
}


vector ( vector && __x ) noexcept
: _Base ( std :: move ( __x ) ) { }

vector ( initializer_list < bool > __l ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a )
{
_M_initialize_range ( __l . begin ( ) , __l . end ( ) ,
random_access_iterator_tag ( ) ) ;
}



template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
vector ( _InputIterator __first , _InputIterator __last ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a )
{ _M_initialize_dispatch ( __first , __last , __false_type ( ) ) ; }
#621
~ vector ( ) noexcept { }

vector &
operator = ( const vector & __x )
{
if ( & __x == this )
return * this ;
if ( __x . size ( ) > capacity ( ) )
{
this -> _M_deallocate ( ) ;
_M_initialize ( __x . size ( ) ) ;
}
this -> _M_impl . _M_finish = _M_copy_aligned ( __x . begin ( ) , __x . end ( ) ,
begin ( ) ) ;
return * this ;
}


vector &
operator = ( vector && __x )
{


this -> clear ( ) ;
this -> swap ( __x ) ;
return * this ;
}

vector &
operator = ( initializer_list < bool > __l )
{
this -> assign ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}
#661
void
assign ( size_type __n , const bool & __x )
{ _M_fill_assign ( __n , __x ) ; }


template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
void
assign ( _InputIterator __first , _InputIterator __last )
{ _M_assign_dispatch ( __first , __last , __false_type ( ) ) ; }
#682
void
assign ( initializer_list < bool > __l )
{ this -> assign ( __l . begin ( ) , __l . end ( ) ) ; }


iterator
begin ( ) noexcept
{ return this -> _M_impl . _M_start ; }

const_iterator
begin ( ) const noexcept
{ return this -> _M_impl . _M_start ; }

iterator
end ( ) noexcept
{ return this -> _M_impl . _M_finish ; }

const_iterator
end ( ) const noexcept
{ return this -> _M_impl . _M_finish ; }

reverse_iterator
rbegin ( ) noexcept
{ return reverse_iterator ( end ( ) ) ; }

const_reverse_iterator
rbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }

reverse_iterator
rend ( ) noexcept
{ return reverse_iterator ( begin ( ) ) ; }

const_reverse_iterator
rend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }


const_iterator
cbegin ( ) const noexcept
{ return this -> _M_impl . _M_start ; }

const_iterator
cend ( ) const noexcept
{ return this -> _M_impl . _M_finish ; }

const_reverse_iterator
crbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }

const_reverse_iterator
crend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }


size_type
size ( ) const noexcept
{ return size_type ( end ( ) - begin ( ) ) ; }

size_type
max_size ( ) const noexcept
{
const size_type __isize =
__gnu_cxx :: __numeric_traits < difference_type > :: __max
- int ( _S_word_bit ) + 1 ;
const size_type __asize = _M_get_Bit_allocator ( ) . max_size ( ) ;
return ( __asize <= __isize / int ( _S_word_bit )
? __asize * int ( _S_word_bit ) : __isize ) ;
}

size_type
capacity ( ) const noexcept
{ return size_type ( const_iterator ( this -> _M_impl . _M_end_of_storage , 0 )
- begin ( ) ) ; }

bool
empty ( ) const noexcept
{ return begin ( ) == end ( ) ; }

reference
operator [ ] ( size_type __n )
{
return * iterator ( this -> _M_impl . _M_start . _M_p
+ __n / int ( _S_word_bit ) , __n % int ( _S_word_bit ) ) ;
}

const_reference
operator [ ] ( size_type __n ) const
{
return * const_iterator ( this -> _M_impl . _M_start . _M_p
+ __n / int ( _S_word_bit ) , __n % int ( _S_word_bit ) ) ;
}

protected :
void
_M_range_check ( size_type __n ) const
{
if ( __n >= this -> size ( ) )
__throw_out_of_range ( ( "vector<bool>::_M_range_check" ) ) ;
}

public :
reference
at ( size_type __n )
{ _M_range_check ( __n ) ; return ( * this ) [ __n ] ; }

const_reference
at ( size_type __n ) const
{ _M_range_check ( __n ) ; return ( * this ) [ __n ] ; }

void
reserve ( size_type __n )
{
if ( __n > max_size ( ) )
__throw_length_error ( ( "vector::reserve" ) ) ;
if ( capacity ( ) < __n )
_M_reallocate ( __n ) ;
}

reference
front ( )
{ return * begin ( ) ; }

const_reference
front ( ) const
{ return * begin ( ) ; }

reference
back ( )
{ return * ( end ( ) - 1 ) ; }

const_reference
back ( ) const
{ return * ( end ( ) - 1 ) ; }
#822
void
data ( ) noexcept { }

void
push_back ( bool __x )
{
if ( this -> _M_impl . _M_finish . _M_p != this -> _M_impl . _M_end_of_storage )
* this -> _M_impl . _M_finish ++ = __x ;
else
_M_insert_aux ( end ( ) , __x ) ;
}

void
swap ( vector & __x )
{
std :: swap ( this -> _M_impl . _M_start , __x . _M_impl . _M_start ) ;
std :: swap ( this -> _M_impl . _M_finish , __x . _M_impl . _M_finish ) ;
std :: swap ( this -> _M_impl . _M_end_of_storage ,
__x . _M_impl . _M_end_of_storage ) ;



std :: __alloc_swap < typename _Base :: _Bit_alloc_type > ::
_S_do_it ( _M_get_Bit_allocator ( ) , __x . _M_get_Bit_allocator ( ) ) ;
}


static void
swap ( reference __x , reference __y ) noexcept
{
bool __tmp = __x ;
__x = __y ;
__y = __tmp ;
}

iterator
insert ( iterator __position , const bool & __x = bool ( ) )
{
const difference_type __n = __position - begin ( ) ;
if ( this -> _M_impl . _M_finish . _M_p != this -> _M_impl . _M_end_of_storage
&& __position == end ( ) )
* this -> _M_impl . _M_finish ++ = __x ;
else
_M_insert_aux ( __position , __x ) ;
return begin ( ) + __n ;
}


template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
void
insert ( iterator __position ,
_InputIterator __first , _InputIterator __last )
{ _M_insert_dispatch ( __position , __first , __last , __false_type ( ) ) ; }
#887
void
insert ( iterator __position , size_type __n , const bool & __x )
{ _M_fill_insert ( __position , __n , __x ) ; }


void insert ( iterator __p , initializer_list < bool > __l )
{ this -> insert ( __p , __l . begin ( ) , __l . end ( ) ) ; }


void
pop_back ( )
{ -- this -> _M_impl . _M_finish ; }

iterator
erase ( iterator __position )
{
if ( __position + 1 != end ( ) )
std :: copy ( __position + 1 , end ( ) , __position ) ;
-- this -> _M_impl . _M_finish ;
return __position ;
}

iterator
erase ( iterator __first , iterator __last )
{
if ( __first != __last )
_M_erase_at_end ( std :: copy ( __last , end ( ) , __first ) ) ;
return __first ;
}

void
resize ( size_type __new_size , bool __x = bool ( ) )
{
if ( __new_size < size ( ) )
_M_erase_at_end ( begin ( ) + difference_type ( __new_size ) ) ;
else
insert ( end ( ) , __new_size - size ( ) , __x ) ;
}


void
shrink_to_fit ( )
{ _M_shrink_to_fit ( ) ; }


void
flip ( ) noexcept
{
for ( _Bit_type * __p = this -> _M_impl . _M_start . _M_p ;
__p != this -> _M_impl . _M_end_of_storage ; ++ __p )
* __p = ~ * __p ;
}

void
clear ( ) noexcept
{ _M_erase_at_end ( begin ( ) ) ; }


protected :

iterator
_M_copy_aligned ( const_iterator __first , const_iterator __last ,
iterator __result )
{
_Bit_type * __q = std :: copy ( __first . _M_p , __last . _M_p , __result . _M_p ) ;
return std :: copy ( const_iterator ( __last . _M_p , 0 ) , __last ,
iterator ( __q , 0 ) ) ;
}

void
_M_initialize ( size_type __n )
{
_Bit_type * __q = this -> _M_allocate ( __n ) ;
this -> _M_impl . _M_end_of_storage = __q + _S_nword ( __n ) ;
this -> _M_impl . _M_start = iterator ( __q , 0 ) ;
this -> _M_impl . _M_finish = this -> _M_impl . _M_start + difference_type ( __n ) ;
}

void
_M_reallocate ( size_type __n ) ;


bool
_M_shrink_to_fit ( ) ;
#977
template < typename _Integer >
void
_M_initialize_dispatch ( _Integer __n , _Integer __x , __true_type )
{
_M_initialize ( static_cast < size_type > ( __n ) ) ;
std :: fill ( this -> _M_impl . _M_start . _M_p ,
this -> _M_impl . _M_end_of_storage , __x ? ~ 0 : 0 ) ;
}

template < typename _InputIterator >
void
_M_initialize_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type )
{ _M_initialize_range ( __first , __last ,
std :: __iterator_category ( __first ) ) ; }

template < typename _InputIterator >
void
_M_initialize_range ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag )
{
for ( ; __first != __last ; ++ __first )
push_back ( * __first ) ;
}

template < typename _ForwardIterator >
void
_M_initialize_range ( _ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag )
{
const size_type __n = std :: distance ( __first , __last ) ;
_M_initialize ( __n ) ;
std :: copy ( __first , __last , this -> _M_impl . _M_start ) ;
}



template < typename _Integer >
void
_M_assign_dispatch ( _Integer __n , _Integer __val , __true_type )
{ _M_fill_assign ( __n , __val ) ; }

template < class _InputIterator >
void
_M_assign_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type )
{ _M_assign_aux ( __first , __last , std :: __iterator_category ( __first ) ) ; }

void
_M_fill_assign ( size_t __n , bool __x )
{
if ( __n > size ( ) )
{
std :: fill ( this -> _M_impl . _M_start . _M_p ,
this -> _M_impl . _M_end_of_storage , __x ? ~ 0 : 0 ) ;
insert ( end ( ) , __n - size ( ) , __x ) ;
}
else
{
_M_erase_at_end ( begin ( ) + __n ) ;
std :: fill ( this -> _M_impl . _M_start . _M_p ,
this -> _M_impl . _M_end_of_storage , __x ? ~ 0 : 0 ) ;
}
}

template < typename _InputIterator >
void
_M_assign_aux ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag )
{
iterator __cur = begin ( ) ;
for ( ; __first != __last && __cur != end ( ) ; ++ __cur , ++ __first )
* __cur = * __first ;
if ( __first == __last )
_M_erase_at_end ( __cur ) ;
else
insert ( end ( ) , __first , __last ) ;
}

template < typename _ForwardIterator >
void
_M_assign_aux ( _ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag )
{
const size_type __len = std :: distance ( __first , __last ) ;
if ( __len < size ( ) )
_M_erase_at_end ( std :: copy ( __first , __last , begin ( ) ) ) ;
else
{
_ForwardIterator __mid = __first ;
std :: advance ( __mid , size ( ) ) ;
std :: copy ( __first , __mid , begin ( ) ) ;
insert ( end ( ) , __mid , __last ) ;
}
}





template < typename _Integer >
void
_M_insert_dispatch ( iterator __pos , _Integer __n , _Integer __x ,
__true_type )
{ _M_fill_insert ( __pos , __n , __x ) ; }

template < typename _InputIterator >
void
_M_insert_dispatch ( iterator __pos ,
_InputIterator __first , _InputIterator __last ,
__false_type )
{ _M_insert_range ( __pos , __first , __last ,
std :: __iterator_category ( __first ) ) ; }

void
_M_fill_insert ( iterator __position , size_type __n , bool __x ) ;

template < typename _InputIterator >
void
_M_insert_range ( iterator __pos , _InputIterator __first ,
_InputIterator __last , std :: input_iterator_tag )
{
for ( ; __first != __last ; ++ __first )
{
__pos = insert ( __pos , * __first ) ;
++ __pos ;
}
}

template < typename _ForwardIterator >
void
_M_insert_range ( iterator __position , _ForwardIterator __first ,
_ForwardIterator __last , std :: forward_iterator_tag ) ;

void
_M_insert_aux ( iterator __position , bool __x ) ;

size_type
_M_check_len ( size_type __n , const char * __s ) const
{
if ( max_size ( ) - size ( ) < __n )
__throw_length_error ( ( __s ) ) ;

const size_type __len = size ( ) + std :: max ( size ( ) , __n ) ;
return ( __len < size ( ) || __len > max_size ( ) ) ? max_size ( ) : __len ;
}

void
_M_erase_at_end ( iterator __pos )
{ this -> _M_impl . _M_finish = __pos ; }
} ;


}
#1136
namespace std
{




template < typename _Alloc >
struct hash < std :: vector < bool , _Alloc >>
: public __hash_base < size_t , std :: vector < bool , _Alloc >>
{
size_t
operator ( ) ( const std :: vector < bool , _Alloc > & ) const noexcept ;
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/vector.tcc"
#59
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 ,
std :: __make_move_if_noexcept_iterator ( this -> _M_impl . _M_start ) ,
std :: __make_move_if_noexcept_iterator ( this -> _M_impl . _M_finish ) ) ;
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __tmp ;
this -> _M_impl . _M_finish = __tmp + __old_size ;
this -> _M_impl . _M_end_of_storage = this -> _M_impl . _M_start + __n ;
}
}


template < typename _Tp , typename _Alloc >
template < typename ... _Args >
void
vector < _Tp , _Alloc > ::
emplace_back ( _Args && ... __args )
{
if ( this -> _M_impl . _M_finish != this -> _M_impl . _M_end_of_storage )
{
_Alloc_traits :: construct ( this -> _M_impl , this -> _M_impl . _M_finish ,
std :: forward < _Args > ( __args ) ... ) ;
++ this -> _M_impl . _M_finish ;
}
else
_M_emplace_back_aux ( std :: forward < _Args > ( __args ) ... ) ;
}


template < typename _Tp , typename _Alloc >
typename vector < _Tp , _Alloc > :: iterator
vector < _Tp , _Alloc > ::
insert ( iterator __position , const value_type & __x )
{
const size_type __n = __position - begin ( ) ;
if ( this -> _M_impl . _M_finish != this -> _M_impl . _M_end_of_storage
&& __position == end ( ) )
{
_Alloc_traits :: construct ( this -> _M_impl , this -> _M_impl . _M_finish , __x ) ;
++ this -> _M_impl . _M_finish ;
}
else
{

if ( this -> _M_impl . _M_finish != this -> _M_impl . _M_end_of_storage )
{
_Tp __x_copy = __x ;
_M_insert_aux ( __position , std :: move ( __x_copy ) ) ;
}
else

_M_insert_aux ( __position , __x ) ;
}
return iterator ( this -> _M_impl . _M_start + __n ) ;
}

template < typename _Tp , typename _Alloc >
typename vector < _Tp , _Alloc > :: iterator
vector < _Tp , _Alloc > ::
erase ( iterator __position )
{
if ( __position + 1 != end ( ) )
std :: move ( __position + 1 , end ( ) , __position ) ;
-- this -> _M_impl . _M_finish ;
_Alloc_traits :: destroy ( this -> _M_impl , this -> _M_impl . _M_finish ) ;
return __position ;
}

template < typename _Tp , typename _Alloc >
typename vector < _Tp , _Alloc > :: iterator
vector < _Tp , _Alloc > ::
erase ( iterator __first , iterator __last )
{
if ( __first != __last )
{
if ( __last != end ( ) )
std :: move ( __last , end ( ) , __first ) ;
_M_erase_at_end ( __first . base ( ) + ( end ( ) - __last ) ) ;
}
return __first ;
}

template < typename _Tp , typename _Alloc >
vector < _Tp , _Alloc > &
vector < _Tp , _Alloc > ::
operator = ( const vector < _Tp , _Alloc > & __x )
{
if ( & __x != this )
{

if ( _Alloc_traits :: _S_propagate_on_copy_assign ( ) )
{
if ( ! _Alloc_traits :: _S_always_equal ( )
&& _M_get_Tp_allocator ( ) != __x . _M_get_Tp_allocator ( ) )
{

this -> clear ( ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = nullptr ;
this -> _M_impl . _M_finish = nullptr ;
this -> _M_impl . _M_end_of_storage = nullptr ;
}
std :: __alloc_on_copy ( _M_get_Tp_allocator ( ) ,
__x . _M_get_Tp_allocator ( ) ) ;
}

const size_type __xlen = __x . size ( ) ;
if ( __xlen > capacity ( ) )
{
pointer __tmp = _M_allocate_and_copy ( __xlen , __x . begin ( ) ,
__x . end ( ) ) ;
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __tmp ;
this -> _M_impl . _M_end_of_storage = this -> _M_impl . _M_start + __xlen ;
}
else if ( size ( ) >= __xlen )
{
std :: _Destroy ( std :: copy ( __x . begin ( ) , __x . end ( ) , begin ( ) ) ,
end ( ) , _M_get_Tp_allocator ( ) ) ;
}
else
{
std :: copy ( __x . _M_impl . _M_start , __x . _M_impl . _M_start + size ( ) ,
this -> _M_impl . _M_start ) ;
std :: __uninitialized_copy_a ( __x . _M_impl . _M_start + size ( ) ,
__x . _M_impl . _M_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
}
this -> _M_impl . _M_finish = this -> _M_impl . _M_start + __xlen ;
}
return * this ;
}

template < typename _Tp , typename _Alloc >
void
vector < _Tp , _Alloc > ::
_M_fill_assign ( size_t __n , const value_type & __val )
{
if ( __n > capacity ( ) )
{
vector __tmp ( __n , __val , _M_get_Tp_allocator ( ) ) ;
__tmp . swap ( * this ) ;
}
else if ( __n > size ( ) )
{
std :: fill ( begin ( ) , end ( ) , __val ) ;
std :: __uninitialized_fill_n_a ( this -> _M_impl . _M_finish ,
__n - size ( ) , __val ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __n - size ( ) ;
}
else
_M_erase_at_end ( std :: fill_n ( this -> _M_impl . _M_start , __n , __val ) ) ;
}

template < typename _Tp , typename _Alloc >
template < typename _InputIterator >
void
vector < _Tp , _Alloc > ::
_M_assign_aux ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag )
{
pointer __cur ( this -> _M_impl . _M_start ) ;
for ( ; __first != __last && __cur != this -> _M_impl . _M_finish ;
++ __cur , ++ __first )
* __cur = * __first ;
if ( __first == __last )
_M_erase_at_end ( __cur ) ;
else
insert ( end ( ) , __first , __last ) ;
}

template < typename _Tp , typename _Alloc >
template < typename _ForwardIterator >
void
vector < _Tp , _Alloc > ::
_M_assign_aux ( _ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag )
{
const size_type __len = std :: distance ( __first , __last ) ;

if ( __len > capacity ( ) )
{
pointer __tmp ( _M_allocate_and_copy ( __len , __first , __last ) ) ;
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __tmp ;
this -> _M_impl . _M_finish = this -> _M_impl . _M_start + __len ;
this -> _M_impl . _M_end_of_storage = this -> _M_impl . _M_finish ;
}
else if ( size ( ) >= __len )
_M_erase_at_end ( std :: copy ( __first , __last , this -> _M_impl . _M_start ) ) ;
else
{
_ForwardIterator __mid = __first ;
std :: advance ( __mid , size ( ) ) ;
std :: copy ( __first , __mid , this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_finish =
std :: __uninitialized_copy_a ( __mid , __last ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
}
}


template < typename _Tp , typename _Alloc >
template < typename ... _Args >
typename vector < _Tp , _Alloc > :: iterator
vector < _Tp , _Alloc > ::
emplace ( iterator __position , _Args && ... __args )
{
const size_type __n = __position - begin ( ) ;
if ( this -> _M_impl . _M_finish != this -> _M_impl . _M_end_of_storage
&& __position == end ( ) )
{
_Alloc_traits :: construct ( this -> _M_impl , this -> _M_impl . _M_finish ,
std :: forward < _Args > ( __args ) ... ) ;
++ this -> _M_impl . _M_finish ;
}
else
_M_insert_aux ( __position , std :: forward < _Args > ( __args ) ... ) ;
return iterator ( this -> _M_impl . _M_start + __n ) ;
}

template < typename _Tp , typename _Alloc >
template < typename ... _Args >
void
vector < _Tp , _Alloc > ::
_M_insert_aux ( iterator __position , _Args && ... __args )
#321
{
if ( this -> _M_impl . _M_finish != this -> _M_impl . _M_end_of_storage )
{
_Alloc_traits :: construct ( this -> _M_impl , this -> _M_impl . _M_finish ,

std :: move ( * ( this -> _M_impl . _M_finish - 1 ) ) ) ;
++ this -> _M_impl . _M_finish ;





std :: move_backward ( __position . base ( ) , this -> _M_impl . _M_finish - 2 , this -> _M_impl . _M_finish - 1 ) ;



* __position = _Tp ( std :: forward < _Args > ( __args ) ... ) ;

}
else
{
const size_type __len =
_M_check_len ( size_type ( 1 ) , "vector::_M_insert_aux" ) ;
const size_type __elems_before = __position - begin ( ) ;
pointer __new_start ( this -> _M_allocate ( __len ) ) ;
pointer __new_finish ( __new_start ) ;
try
{




_Alloc_traits :: construct ( this -> _M_impl ,
__new_start + __elems_before ,

std :: forward < _Args > ( __args ) ... ) ;



__new_finish = 0 ;

__new_finish
= std :: __uninitialized_move_if_noexcept_a
( this -> _M_impl . _M_start , __position . base ( ) ,
__new_start , _M_get_Tp_allocator ( ) ) ;

++ __new_finish ;

__new_finish
= std :: __uninitialized_move_if_noexcept_a
( __position . base ( ) , this -> _M_impl . _M_finish ,
__new_finish , _M_get_Tp_allocator ( ) ) ;
}
catch ( ... )
{
if ( ! __new_finish )
_Alloc_traits :: destroy ( this -> _M_impl ,
__new_start + __elems_before ) ;
else
std :: _Destroy ( __new_start , __new_finish , _M_get_Tp_allocator ( ) ) ;
_M_deallocate ( __new_start , __len ) ;
throw ;
}
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __new_start ;
this -> _M_impl . _M_finish = __new_finish ;
this -> _M_impl . _M_end_of_storage = __new_start + __len ;
}
}


template < typename _Tp , typename _Alloc >
template < typename ... _Args >
void
vector < _Tp , _Alloc > ::
_M_emplace_back_aux ( _Args && ... __args )
{
const size_type __len =
_M_check_len ( size_type ( 1 ) , "vector::_M_emplace_back_aux" ) ;
pointer __new_start ( this -> _M_allocate ( __len ) ) ;
pointer __new_finish ( __new_start ) ;
try
{
_Alloc_traits :: construct ( this -> _M_impl , __new_start + size ( ) ,
std :: forward < _Args > ( __args ) ... ) ;
__new_finish = 0 ;

__new_finish
= std :: __uninitialized_move_if_noexcept_a
( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
__new_start , _M_get_Tp_allocator ( ) ) ;

++ __new_finish ;
}
catch ( ... )
{
if ( ! __new_finish )
_Alloc_traits :: destroy ( this -> _M_impl , __new_start + size ( ) ) ;
else
std :: _Destroy ( __new_start , __new_finish , _M_get_Tp_allocator ( ) ) ;
_M_deallocate ( __new_start , __len ) ;
throw ;
}
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __new_start ;
this -> _M_impl . _M_finish = __new_finish ;
this -> _M_impl . _M_end_of_storage = __new_start + __len ;
}


template < typename _Tp , typename _Alloc >
void
vector < _Tp , _Alloc > ::
_M_fill_insert ( iterator __position , size_type __n , const value_type & __x )
{
if ( __n != 0 )
{
if ( size_type ( this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_finish ) >= __n )
{
value_type __x_copy = __x ;
const size_type __elems_after = end ( ) - __position ;
pointer __old_finish ( this -> _M_impl . _M_finish ) ;
if ( __elems_after > __n )
{
std :: __uninitialized_move_a ( this -> _M_impl . _M_finish - __n ,
this -> _M_impl . _M_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __n ;

std :: move_backward ( __position . base ( ) , __old_finish - __n , __old_finish ) ;
std :: fill ( __position . base ( ) , __position . base ( ) + __n ,
__x_copy ) ;
}
else
{
std :: __uninitialized_fill_n_a ( this -> _M_impl . _M_finish ,
__n - __elems_after ,
__x_copy ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __n - __elems_after ;
std :: __uninitialized_move_a ( __position . base ( ) , __old_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __elems_after ;
std :: fill ( __position . base ( ) , __old_finish , __x_copy ) ;
}
}
else
{
const size_type __len =
_M_check_len ( __n , "vector::_M_fill_insert" ) ;
const size_type __elems_before = __position - begin ( ) ;
pointer __new_start ( this -> _M_allocate ( __len ) ) ;
pointer __new_finish ( __new_start ) ;
try
{

std :: __uninitialized_fill_n_a ( __new_start + __elems_before ,
__n , __x ,
_M_get_Tp_allocator ( ) ) ;
__new_finish = 0 ;

__new_finish
= std :: __uninitialized_move_if_noexcept_a
( this -> _M_impl . _M_start , __position . base ( ) ,
__new_start , _M_get_Tp_allocator ( ) ) ;

__new_finish += __n ;

__new_finish
= std :: __uninitialized_move_if_noexcept_a
( __position . base ( ) , this -> _M_impl . _M_finish ,
__new_finish , _M_get_Tp_allocator ( ) ) ;
}
catch ( ... )
{
if ( ! __new_finish )
std :: _Destroy ( __new_start + __elems_before ,
__new_start + __elems_before + __n ,
_M_get_Tp_allocator ( ) ) ;
else
std :: _Destroy ( __new_start , __new_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( __new_start , __len ) ;
throw ;
}
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __new_start ;
this -> _M_impl . _M_finish = __new_finish ;
this -> _M_impl . _M_end_of_storage = __new_start + __len ;
}
}
}


template < typename _Tp , typename _Alloc >
void
vector < _Tp , _Alloc > ::
_M_default_append ( size_type __n )
{
if ( __n != 0 )
{
if ( size_type ( this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_finish ) >= __n )
{
std :: __uninitialized_default_n_a ( this -> _M_impl . _M_finish ,
__n , _M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __n ;
}
else
{
const size_type __len =
_M_check_len ( __n , "vector::_M_default_append" ) ;
const size_type __old_size = this -> size ( ) ;
pointer __new_start ( this -> _M_allocate ( __len ) ) ;
pointer __new_finish ( __new_start ) ;
try
{
__new_finish
= std :: __uninitialized_move_if_noexcept_a
( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
__new_start , _M_get_Tp_allocator ( ) ) ;
std :: __uninitialized_default_n_a ( __new_finish , __n ,
_M_get_Tp_allocator ( ) ) ;
__new_finish += __n ;
}
catch ( ... )
{
std :: _Destroy ( __new_start , __new_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( __new_start , __len ) ;
throw ;
}
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __new_start ;
this -> _M_impl . _M_finish = __new_finish ;
this -> _M_impl . _M_end_of_storage = __new_start + __len ;
}
}
}

template < typename _Tp , typename _Alloc >
bool
vector < _Tp , _Alloc > ::
_M_shrink_to_fit ( )
{
if ( capacity ( ) == size ( ) )
return false ;
return std :: __shrink_to_fit_aux < vector > :: _S_do_it ( * this ) ;
}


template < typename _Tp , typename _Alloc >
template < typename _InputIterator >
void
vector < _Tp , _Alloc > ::
_M_range_insert ( iterator __pos , _InputIterator __first ,
_InputIterator __last , std :: input_iterator_tag )
{
for ( ; __first != __last ; ++ __first )
{
__pos = insert ( __pos , * __first ) ;
++ __pos ;
}
}

template < typename _Tp , typename _Alloc >
template < typename _ForwardIterator >
void
vector < _Tp , _Alloc > ::
_M_range_insert ( iterator __position , _ForwardIterator __first ,
_ForwardIterator __last , std :: forward_iterator_tag )
{
if ( __first != __last )
{
const size_type __n = std :: distance ( __first , __last ) ;
if ( size_type ( this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_finish ) >= __n )
{
const size_type __elems_after = end ( ) - __position ;
pointer __old_finish ( this -> _M_impl . _M_finish ) ;
if ( __elems_after > __n )
{
std :: __uninitialized_move_a ( this -> _M_impl . _M_finish - __n ,
this -> _M_impl . _M_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __n ;

std :: move_backward ( __position . base ( ) , __old_finish - __n , __old_finish ) ;
std :: copy ( __first , __last , __position ) ;
}
else
{
_ForwardIterator __mid = __first ;
std :: advance ( __mid , __elems_after ) ;
std :: __uninitialized_copy_a ( __mid , __last ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __n - __elems_after ;
std :: __uninitialized_move_a ( __position . base ( ) ,
__old_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish += __elems_after ;
std :: copy ( __first , __mid , __position ) ;
}
}
else
{
const size_type __len =
_M_check_len ( __n , "vector::_M_range_insert" ) ;
pointer __new_start ( this -> _M_allocate ( __len ) ) ;
pointer __new_finish ( __new_start ) ;
try
{
__new_finish
= std :: __uninitialized_move_if_noexcept_a
( this -> _M_impl . _M_start , __position . base ( ) ,
__new_start , _M_get_Tp_allocator ( ) ) ;
__new_finish
= std :: __uninitialized_copy_a ( __first , __last ,
__new_finish ,
_M_get_Tp_allocator ( ) ) ;
__new_finish
= std :: __uninitialized_move_if_noexcept_a
( __position . base ( ) , this -> _M_impl . _M_finish ,
__new_finish , _M_get_Tp_allocator ( ) ) ;
}
catch ( ... )
{
std :: _Destroy ( __new_start , __new_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( __new_start , __len ) ;
throw ;
}
std :: _Destroy ( this -> _M_impl . _M_start , this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
_M_deallocate ( this -> _M_impl . _M_start ,
this -> _M_impl . _M_end_of_storage
- this -> _M_impl . _M_start ) ;
this -> _M_impl . _M_start = __new_start ;
this -> _M_impl . _M_finish = __new_finish ;
this -> _M_impl . _M_end_of_storage = __new_start + __len ;
}
}
}



template < typename _Alloc >
void
vector < bool , _Alloc > ::
_M_reallocate ( size_type __n )
{
_Bit_type * __q = this -> _M_allocate ( __n ) ;
this -> _M_impl . _M_finish = _M_copy_aligned ( begin ( ) , end ( ) ,
iterator ( __q , 0 ) ) ;
this -> _M_deallocate ( ) ;
this -> _M_impl . _M_start = iterator ( __q , 0 ) ;
this -> _M_impl . _M_end_of_storage = __q + _S_nword ( __n ) ;
}

template < typename _Alloc >
void
vector < bool , _Alloc > ::
_M_fill_insert ( iterator __position , size_type __n , bool __x )
{
if ( __n == 0 )
return ;
if ( capacity ( ) - size ( ) >= __n )
{
std :: copy_backward ( __position , end ( ) ,
this -> _M_impl . _M_finish + difference_type ( __n ) ) ;
std :: fill ( __position , __position + difference_type ( __n ) , __x ) ;
this -> _M_impl . _M_finish += difference_type ( __n ) ;
}
else
{
const size_type __len =
_M_check_len ( __n , "vector<bool>::_M_fill_insert" ) ;
_Bit_type * __q = this -> _M_allocate ( __len ) ;
iterator __i = _M_copy_aligned ( begin ( ) , __position ,
iterator ( __q , 0 ) ) ;
std :: fill ( __i , __i + difference_type ( __n ) , __x ) ;
this -> _M_impl . _M_finish = std :: copy ( __position , end ( ) ,
__i + difference_type ( __n ) ) ;
this -> _M_deallocate ( ) ;
this -> _M_impl . _M_end_of_storage = __q + _S_nword ( __len ) ;
this -> _M_impl . _M_start = iterator ( __q , 0 ) ;
}
}

template < typename _Alloc >
template < typename _ForwardIterator >
void
vector < bool , _Alloc > ::
_M_insert_range ( iterator __position , _ForwardIterator __first ,
_ForwardIterator __last , std :: forward_iterator_tag )
{
if ( __first != __last )
{
size_type __n = std :: distance ( __first , __last ) ;
if ( capacity ( ) - size ( ) >= __n )
{
std :: copy_backward ( __position , end ( ) ,
this -> _M_impl . _M_finish
+ difference_type ( __n ) ) ;
std :: copy ( __first , __last , __position ) ;
this -> _M_impl . _M_finish += difference_type ( __n ) ;
}
else
{
const size_type __len =
_M_check_len ( __n , "vector<bool>::_M_insert_range" ) ;
_Bit_type * __q = this -> _M_allocate ( __len ) ;
iterator __i = _M_copy_aligned ( begin ( ) , __position ,
iterator ( __q , 0 ) ) ;
__i = std :: copy ( __first , __last , __i ) ;
this -> _M_impl . _M_finish = std :: copy ( __position , end ( ) , __i ) ;
this -> _M_deallocate ( ) ;
this -> _M_impl . _M_end_of_storage = __q + _S_nword ( __len ) ;
this -> _M_impl . _M_start = iterator ( __q , 0 ) ;
}
}
}

template < typename _Alloc >
void
vector < bool , _Alloc > ::
_M_insert_aux ( iterator __position , bool __x )
{
if ( this -> _M_impl . _M_finish . _M_p != this -> _M_impl . _M_end_of_storage )
{
std :: copy_backward ( __position , this -> _M_impl . _M_finish ,
this -> _M_impl . _M_finish + 1 ) ;
* __position = __x ;
++ this -> _M_impl . _M_finish ;
}
else
{
const size_type __len =
_M_check_len ( size_type ( 1 ) , "vector<bool>::_M_insert_aux" ) ;
_Bit_type * __q = this -> _M_allocate ( __len ) ;
iterator __i = _M_copy_aligned ( begin ( ) , __position ,
iterator ( __q , 0 ) ) ;
* __i ++ = __x ;
this -> _M_impl . _M_finish = std :: copy ( __position , end ( ) , __i ) ;
this -> _M_deallocate ( ) ;
this -> _M_impl . _M_end_of_storage = __q + _S_nword ( __len ) ;
this -> _M_impl . _M_start = iterator ( __q , 0 ) ;
}
}


template < typename _Alloc >
bool
vector < bool , _Alloc > ::
_M_shrink_to_fit ( )
{
if ( capacity ( ) - size ( ) < int ( _S_word_bit ) )
return false ;
try
{
_M_reallocate ( size ( ) ) ;
return true ;
}
catch ( ... )
{ return false ; }
}



}



namespace std
{


template < typename _Alloc >
size_t
hash < std :: vector < bool , _Alloc >> ::
operator ( ) ( const std :: vector < bool , _Alloc > & __b ) const noexcept
{
size_t __hash = 0 ;
using std :: _S_word_bit ;
using std :: _Bit_type ;

const size_t __words = __b . size ( ) / _S_word_bit ;
if ( __words )
{
const size_t __clength = __words * sizeof ( _Bit_type ) ;
__hash = std :: _Hash_impl :: hash ( __b . _M_impl . _M_start . _M_p , __clength ) ;
}

const size_t __extrabits = __b . size ( ) % _S_word_bit ;
if ( __extrabits )
{
_Bit_type __hiword = * __b . _M_impl . _M_finish . _M_p ;
__hiword &= ~ ( ( ~ static_cast < _Bit_type > ( 0 ) ) << __extrabits ) ;

const size_t __clength
= ( __extrabits + 8 - 1 ) / 8 ;
if ( __words )
__hash = std :: _Hash_impl :: hash ( & __hiword , __clength , __hash ) ;
else
__hash = std :: _Hash_impl :: hash ( & __hiword , __clength ) ;
}

return __hash ;
}


}
#36 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/random.h"
namespace std
{
#55
template < typename _RealType , size_t __bits ,
typename _UniformRandomNumberGenerator >
_RealType
generate_canonical ( _UniformRandomNumberGenerator & __g ) ;
#65
namespace __detail
{


template < typename _UIntType , size_t __w ,
bool = __w < static_cast < size_t >
( std :: numeric_limits < _UIntType > :: digits ) >
struct _Shift
{ static const _UIntType __value = 0 ; } ;

template < typename _UIntType , size_t __w >
struct _Shift < _UIntType , __w , true >
{ static const _UIntType __value = _UIntType ( 1 ) << __w ; } ;

template < int __s ,
int __which = ( ( __s <= 8 * sizeof ( int ) )
+ ( __s <= 8 * sizeof ( long ) )
+ ( __s <= 8 * sizeof ( long long ) )

+ ( __s <= 128 ) ) >
struct _Select_uint_least_t
{
static_assert ( __which < 0 ,
"sorry, would be too much trouble for a slow result" ) ;
} ;

template < int __s >
struct _Select_uint_least_t < __s , 4 >
{ typedef unsigned int type ; } ;

template < int __s >
struct _Select_uint_least_t < __s , 3 >
{ typedef unsigned long type ; } ;

template < int __s >
struct _Select_uint_least_t < __s , 2 >
{ typedef unsigned long long type ; } ;
#110
template < typename _Tp , _Tp __m , _Tp __a , _Tp __c ,
bool __big_enough = ( ! ( __m & ( __m - 1 ) )
|| ( _Tp ( - 1 ) - __c ) / __a >= __m - 1 ) ,
bool __schrage_ok = __m % __a < __m / __a >
struct _Mod
{
typedef typename _Select_uint_least_t < std :: __lg ( __a )
+ std :: __lg ( __m ) + 2 > :: type _Tp2 ;
static _Tp
__calc ( _Tp __x )
{ return static_cast < _Tp > ( ( _Tp2 ( __a ) * __x + __c ) % __m ) ; }
} ;


template < typename _Tp , _Tp __m , _Tp __a , _Tp __c >
struct _Mod < _Tp , __m , __a , __c , false , true >
{
static _Tp
__calc ( _Tp __x ) ;
} ;




template < typename _Tp , _Tp __m , _Tp __a , _Tp __c , bool __s >
struct _Mod < _Tp , __m , __a , __c , true , __s >
{
static _Tp
__calc ( _Tp __x )
{
_Tp __res = __a * __x + __c ;
if ( __m )
__res %= __m ;
return __res ;
}
} ;

template < typename _Tp , _Tp __m , _Tp __a = 1 , _Tp __c = 0 >
inline _Tp
__mod ( _Tp __x )
{ return _Mod < _Tp , __m , __a , __c > :: __calc ( __x ) ; }


template < typename _Tp >
inline bool
_Power_of_2 ( _Tp __x )
{
return ( ( __x - 1 ) & __x ) == 0 ;
} ;





template < typename _Engine , typename _DInputType >
struct _Adaptor
{

public :
_Adaptor ( _Engine & __g )
: _M_g ( __g ) { }

_DInputType
min ( ) const
{ return _DInputType ( 0 ) ; }

_DInputType
max ( ) const
{ return _DInputType ( 1 ) ; }
#185
_DInputType
operator ( ) ( )
{
return std :: generate_canonical < _DInputType ,
std :: numeric_limits < _DInputType > :: digits ,
_Engine > ( _M_g ) ;
}

private :
_Engine & _M_g ;
} ;


}
#240
template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
class linear_congruential_engine
{
static_assert ( std :: is_unsigned < _UIntType > :: value , "template argument "
"substituting _UIntType not an unsigned integral type" ) ;
static_assert ( __m == 0u || ( __a < __m && __c < __m ) ,
"template argument substituting __m out of bounds" ) ;

public :

typedef _UIntType result_type ;


static constexpr result_type multiplier = __a ;

static constexpr result_type increment = __c ;

static constexpr result_type modulus = __m ;
static constexpr result_type default_seed = 1u ;
#267
explicit
linear_congruential_engine ( result_type __s = default_seed )
{ seed ( __s ) ; }
#277
template < typename _Sseq , typename = typename
std :: enable_if < ! std :: is_same < _Sseq , linear_congruential_engine > :: value >
:: type >
explicit
linear_congruential_engine ( _Sseq & __q )
{ seed ( __q ) ; }
#290
void
seed ( result_type __s = default_seed ) ;
#300
template < typename _Sseq >
typename std :: enable_if < std :: is_class < _Sseq > :: value > :: type
seed ( _Sseq & __q ) ;
#310
static constexpr result_type
min ( )
{ return __c == 0u ? 1u : 0u ; }




static constexpr result_type
max ( )
{ return __m - 1u ; }




void
discard ( unsigned long long __z )
{
for ( ; __z != 0ULL ; -- __z )
( * this ) ( ) ;
}




result_type
operator ( ) ( )
{
_M_x = __detail :: __mod < _UIntType , __m , __a , __c > ( _M_x ) ;
return _M_x ;
}
#352
friend bool
operator == ( const linear_congruential_engine & __lhs ,
const linear_congruential_engine & __rhs )
{ return __lhs . _M_x == __rhs . _M_x ; }
#365
template < typename _UIntType1 , _UIntType1 __a1 , _UIntType1 __c1 ,
_UIntType1 __m1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: linear_congruential_engine < _UIntType1 ,
__a1 , __c1 , __m1 > & __lcr ) ;
#385
template < typename _UIntType1 , _UIntType1 __a1 , _UIntType1 __c1 ,
_UIntType1 __m1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: linear_congruential_engine < _UIntType1 , __a1 ,
__c1 , __m1 > & __lcr ) ;

private :
_UIntType _M_x ;
} ;
#407
template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
inline bool
operator != ( const std :: linear_congruential_engine < _UIntType , __a ,
__c , __m > & __lhs ,
const std :: linear_congruential_engine < _UIntType , __a ,
__c , __m > & __rhs )
{ return ! ( __lhs == __rhs ) ; }
#444
template < typename _UIntType , size_t __w ,
size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t ,
_UIntType __c , size_t __l , _UIntType __f >
class mersenne_twister_engine
{
static_assert ( std :: is_unsigned < _UIntType > :: value , "template argument "
"substituting _UIntType not an unsigned integral type" ) ;
static_assert ( 1u <= __m && __m <= __n ,
"template argument substituting __m out of bounds" ) ;
static_assert ( __r <= __w , "template argument substituting "
"__r out of bound" ) ;
static_assert ( __u <= __w , "template argument substituting "
"__u out of bound" ) ;
static_assert ( __s <= __w , "template argument substituting "
"__s out of bound" ) ;
static_assert ( __t <= __w , "template argument substituting "
"__t out of bound" ) ;
static_assert ( __l <= __w , "template argument substituting "
"__l out of bound" ) ;
static_assert ( __w <= std :: numeric_limits < _UIntType > :: digits ,
"template argument substituting __w out of bound" ) ;
static_assert ( __a <= ( __detail :: _Shift < _UIntType , __w > :: __value - 1 ) ,
"template argument substituting __a out of bound" ) ;
static_assert ( __b <= ( __detail :: _Shift < _UIntType , __w > :: __value - 1 ) ,
"template argument substituting __b out of bound" ) ;
static_assert ( __c <= ( __detail :: _Shift < _UIntType , __w > :: __value - 1 ) ,
"template argument substituting __c out of bound" ) ;
static_assert ( __d <= ( __detail :: _Shift < _UIntType , __w > :: __value - 1 ) ,
"template argument substituting __d out of bound" ) ;
static_assert ( __f <= ( __detail :: _Shift < _UIntType , __w > :: __value - 1 ) ,
"template argument substituting __f out of bound" ) ;

public :

typedef _UIntType result_type ;


static constexpr size_t word_size = __w ;
static constexpr size_t state_size = __n ;
static constexpr size_t shift_size = __m ;
static constexpr size_t mask_bits = __r ;
static constexpr result_type xor_mask = __a ;
static constexpr size_t tempering_u = __u ;
static constexpr result_type tempering_d = __d ;
static constexpr size_t tempering_s = __s ;
static constexpr result_type tempering_b = __b ;
static constexpr size_t tempering_t = __t ;
static constexpr result_type tempering_c = __c ;
static constexpr size_t tempering_l = __l ;
static constexpr result_type initialization_multiplier = __f ;
static constexpr result_type default_seed = 5489u ;


explicit
mersenne_twister_engine ( result_type __sd = default_seed )
{ seed ( __sd ) ; }
#509
template < typename _Sseq , typename = typename
std :: enable_if < ! std :: is_same < _Sseq , mersenne_twister_engine > :: value >
:: type >
explicit
mersenne_twister_engine ( _Sseq & __q )
{ seed ( __q ) ; }

void
seed ( result_type __sd = default_seed ) ;

template < typename _Sseq >
typename std :: enable_if < std :: is_class < _Sseq > :: value > :: type
seed ( _Sseq & __q ) ;




static constexpr result_type
min ( )
{ return 0 ; } ;




static constexpr result_type
max ( )
{ return __detail :: _Shift < _UIntType , __w > :: __value - 1 ; }




void
discard ( unsigned long long __z ) ;

result_type
operator ( ) ( ) ;
#558
friend bool
operator == ( const mersenne_twister_engine & __lhs ,
const mersenne_twister_engine & __rhs )
{ return ( std :: equal ( __lhs . _M_x , __lhs . _M_x + state_size , __rhs . _M_x )
&& __lhs . _M_p == __rhs . _M_p ) ; }
#576
template < typename _UIntType1 ,
size_t __w1 , size_t __n1 ,
size_t __m1 , size_t __r1 ,
_UIntType1 __a1 , size_t __u1 ,
_UIntType1 __d1 , size_t __s1 ,
_UIntType1 __b1 , size_t __t1 ,
_UIntType1 __c1 , size_t __l1 , _UIntType1 __f1 ,
typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: mersenne_twister_engine < _UIntType1 , __w1 , __n1 ,
__m1 , __r1 , __a1 , __u1 , __d1 , __s1 , __b1 , __t1 , __c1 ,
__l1 , __f1 > & __x ) ;
#602
template < typename _UIntType1 ,
size_t __w1 , size_t __n1 ,
size_t __m1 , size_t __r1 ,
_UIntType1 __a1 , size_t __u1 ,
_UIntType1 __d1 , size_t __s1 ,
_UIntType1 __b1 , size_t __t1 ,
_UIntType1 __c1 , size_t __l1 , _UIntType1 __f1 ,
typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: mersenne_twister_engine < _UIntType1 , __w1 , __n1 , __m1 ,
__r1 , __a1 , __u1 , __d1 , __s1 , __b1 , __t1 , __c1 ,
__l1 , __f1 > & __x ) ;

private :
void _M_gen_rand ( ) ;

_UIntType _M_x [ state_size ] ;
size_t _M_p ;
} ;
#635
template < typename _UIntType , size_t __w ,
size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t ,
_UIntType __c , size_t __l , _UIntType __f >
inline bool
operator != ( const std :: mersenne_twister_engine < _UIntType , __w , __n , __m ,
__r , __a , __u , __d , __s , __b , __t , __c , __l , __f > & __lhs ,
const std :: mersenne_twister_engine < _UIntType , __w , __n , __m ,
__r , __a , __u , __d , __s , __b , __t , __c , __l , __f > & __rhs )
{ return ! ( __lhs == __rhs ) ; }
#667
template < typename _UIntType , size_t __w , size_t __s , size_t __r >
class subtract_with_carry_engine
{
static_assert ( std :: is_unsigned < _UIntType > :: value , "template argument "
"substituting _UIntType not an unsigned integral type" ) ;
static_assert ( 0u < __s && __s < __r ,
"template argument substituting __s out of bounds" ) ;
static_assert ( 0u < __w && __w <= std :: numeric_limits < _UIntType > :: digits ,
"template argument substituting __w out of bounds" ) ;

public :

typedef _UIntType result_type ;


static constexpr size_t word_size = __w ;
static constexpr size_t short_lag = __s ;
static constexpr size_t long_lag = __r ;
static constexpr result_type default_seed = 19780503u ;





explicit
subtract_with_carry_engine ( result_type __sd = default_seed )
{ seed ( __sd ) ; }
#701
template < typename _Sseq , typename = typename
std :: enable_if < ! std :: is_same < _Sseq , subtract_with_carry_engine > :: value >
:: type >
explicit
subtract_with_carry_engine ( _Sseq & __q )
{ seed ( __q ) ; }
#720
void
seed ( result_type __sd = default_seed ) ;





template < typename _Sseq >
typename std :: enable_if < std :: is_class < _Sseq > :: value > :: type
seed ( _Sseq & __q ) ;





static constexpr result_type
min ( )
{ return 0 ; }





static constexpr result_type
max ( )
{ return __detail :: _Shift < _UIntType , __w > :: __value - 1 ; }




void
discard ( unsigned long long __z )
{
for ( ; __z != 0ULL ; -- __z )
( * this ) ( ) ;
}




result_type
operator ( ) ( ) ;
#775
friend bool
operator == ( const subtract_with_carry_engine & __lhs ,
const subtract_with_carry_engine & __rhs )
{ return ( std :: equal ( __lhs . _M_x , __lhs . _M_x + long_lag , __rhs . _M_x )
&& __lhs . _M_carry == __rhs . _M_carry
&& __lhs . _M_p == __rhs . _M_p ) ; }
#794
template < typename _UIntType1 , size_t __w1 , size_t __s1 , size_t __r1 ,
typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & ,
const std :: subtract_with_carry_engine < _UIntType1 , __w1 ,
__s1 , __r1 > & ) ;
#813
template < typename _UIntType1 , size_t __w1 , size_t __s1 , size_t __r1 ,
typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & ,
std :: subtract_with_carry_engine < _UIntType1 , __w1 ,
__s1 , __r1 > & ) ;

private :
_UIntType _M_x [ long_lag ] ;
_UIntType _M_carry ;
size_t _M_p ;
} ;
#838
template < typename _UIntType , size_t __w , size_t __s , size_t __r >
inline bool
operator != ( const std :: subtract_with_carry_engine < _UIntType , __w ,
__s , __r > & __lhs ,
const std :: subtract_with_carry_engine < _UIntType , __w ,
__s , __r > & __rhs )
{ return ! ( __lhs == __rhs ) ; }
#853
template < typename _RandomNumberEngine , size_t __p , size_t __r >
class discard_block_engine
{
static_assert ( 1 <= __r && __r <= __p ,
"template argument substituting __r out of bounds" ) ;

public :

typedef typename _RandomNumberEngine :: result_type result_type ;


static constexpr size_t block_size = __p ;
static constexpr size_t used_block = __r ;
#872
discard_block_engine ( )
: _M_b ( ) , _M_n ( 0 ) { }
#881
explicit
discard_block_engine ( const _RandomNumberEngine & __rng )
: _M_b ( __rng ) , _M_n ( 0 ) { }
#891
explicit
discard_block_engine ( _RandomNumberEngine && __rng )
: _M_b ( std :: move ( __rng ) ) , _M_n ( 0 ) { }
#901
explicit
discard_block_engine ( result_type __s )
: _M_b ( __s ) , _M_n ( 0 ) { }
#910
template < typename _Sseq , typename = typename
std :: enable_if < ! std :: is_same < _Sseq , discard_block_engine > :: value
&& ! std :: is_same < _Sseq , _RandomNumberEngine > :: value >
:: type >
explicit
discard_block_engine ( _Sseq & __q )
: _M_b ( __q ) , _M_n ( 0 )
{ }





void
seed ( )
{
_M_b . seed ( ) ;
_M_n = 0 ;
}





void
seed ( result_type __s )
{
_M_b . seed ( __s ) ;
_M_n = 0 ;
}
#946
template < typename _Sseq >
void
seed ( _Sseq & __q )
{
_M_b . seed ( __q ) ;
_M_n = 0 ;
}





const _RandomNumberEngine &
base ( ) const noexcept
{ return _M_b ; }




static constexpr result_type
min ( )
{ return _RandomNumberEngine :: min ( ) ; }




static constexpr result_type
max ( )
{ return _RandomNumberEngine :: max ( ) ; }




void
discard ( unsigned long long __z )
{
for ( ; __z != 0ULL ; -- __z )
( * this ) ( ) ;
}




result_type
operator ( ) ( ) ;
#1003
friend bool
operator == ( const discard_block_engine & __lhs ,
const discard_block_engine & __rhs )
{ return __lhs . _M_b == __rhs . _M_b && __lhs . _M_n == __rhs . _M_n ; }
#1019
template < typename _RandomNumberEngine1 , size_t __p1 , size_t __r1 ,
typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: discard_block_engine < _RandomNumberEngine1 ,
__p1 , __r1 > & __x ) ;
#1037
template < typename _RandomNumberEngine1 , size_t __p1 , size_t __r1 ,
typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: discard_block_engine < _RandomNumberEngine1 ,
__p1 , __r1 > & __x ) ;

private :
_RandomNumberEngine _M_b ;
size_t _M_n ;
} ;
#1060
template < typename _RandomNumberEngine , size_t __p , size_t __r >
inline bool
operator != ( const std :: discard_block_engine < _RandomNumberEngine , __p ,
__r > & __lhs ,
const std :: discard_block_engine < _RandomNumberEngine , __p ,
__r > & __rhs )
{ return ! ( __lhs == __rhs ) ; }
#1073
template < typename _RandomNumberEngine , size_t __w , typename _UIntType >
class independent_bits_engine
{
static_assert ( std :: is_unsigned < _UIntType > :: value , "template argument "
"substituting _UIntType not an unsigned integral type" ) ;
static_assert ( 0u < __w && __w <= std :: numeric_limits < _UIntType > :: digits ,
"template argument substituting __w out of bounds" ) ;

public :

typedef _UIntType result_type ;
#1090
independent_bits_engine ( )
: _M_b ( ) { }
#1099
explicit
independent_bits_engine ( const _RandomNumberEngine & __rng )
: _M_b ( __rng ) { }
#1109
explicit
independent_bits_engine ( _RandomNumberEngine && __rng )
: _M_b ( std :: move ( __rng ) ) { }
#1119
explicit
independent_bits_engine ( result_type __s )
: _M_b ( __s ) { }
#1128
template < typename _Sseq , typename = typename
std :: enable_if < ! std :: is_same < _Sseq , independent_bits_engine > :: value
&& ! std :: is_same < _Sseq , _RandomNumberEngine > :: value >
:: type >
explicit
independent_bits_engine ( _Sseq & __q )
: _M_b ( __q )
{ }





void
seed ( )
{ _M_b . seed ( ) ; }





void
seed ( result_type __s )
{ _M_b . seed ( __s ) ; }
#1158
template < typename _Sseq >
void
seed ( _Sseq & __q )
{ _M_b . seed ( __q ) ; }





const _RandomNumberEngine &
base ( ) const noexcept
{ return _M_b ; }




static constexpr result_type
min ( )
{ return 0U ; }




static constexpr result_type
max ( )
{ return __detail :: _Shift < _UIntType , __w > :: __value - 1 ; }




void
discard ( unsigned long long __z )
{
for ( ; __z != 0ULL ; -- __z )
( * this ) ( ) ;
}




result_type
operator ( ) ( ) ;
#1213
friend bool
operator == ( const independent_bits_engine & __lhs ,
const independent_bits_engine & __rhs )
{ return __lhs . _M_b == __rhs . _M_b ; }
#1230
template < typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: independent_bits_engine < _RandomNumberEngine ,
__w , _UIntType > & __x )
{
__is >> __x . _M_b ;
return __is ;
}

private :
_RandomNumberEngine _M_b ;
} ;
#1256
template < typename _RandomNumberEngine , size_t __w , typename _UIntType >
inline bool
operator != ( const std :: independent_bits_engine < _RandomNumberEngine , __w ,
_UIntType > & __lhs ,
const std :: independent_bits_engine < _RandomNumberEngine , __w ,
_UIntType > & __rhs )
{ return ! ( __lhs == __rhs ) ; }
#1274
template < typename _RandomNumberEngine , size_t __w , typename _UIntType ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: independent_bits_engine < _RandomNumberEngine ,
__w , _UIntType > & __x )
{
__os << __x . base ( ) ;
return __os ;
}
#1291
template < typename _RandomNumberEngine , size_t __k >
class shuffle_order_engine
{
static_assert ( 1u <= __k , "template argument substituting "
"__k out of bound" ) ;

public :

typedef typename _RandomNumberEngine :: result_type result_type ;

static constexpr size_t table_size = __k ;
#1308
shuffle_order_engine ( )
: _M_b ( )
{ _M_initialize ( ) ; }
#1318
explicit
shuffle_order_engine ( const _RandomNumberEngine & __rng )
: _M_b ( __rng )
{ _M_initialize ( ) ; }
#1329
explicit
shuffle_order_engine ( _RandomNumberEngine && __rng )
: _M_b ( std :: move ( __rng ) )
{ _M_initialize ( ) ; }
#1340
explicit
shuffle_order_engine ( result_type __s )
: _M_b ( __s )
{ _M_initialize ( ) ; }
#1350
template < typename _Sseq , typename = typename
std :: enable_if < ! std :: is_same < _Sseq , shuffle_order_engine > :: value
&& ! std :: is_same < _Sseq , _RandomNumberEngine > :: value >
:: type >
explicit
shuffle_order_engine ( _Sseq & __q )
: _M_b ( __q )
{ _M_initialize ( ) ; }





void
seed ( )
{
_M_b . seed ( ) ;
_M_initialize ( ) ;
}





void
seed ( result_type __s )
{
_M_b . seed ( __s ) ;
_M_initialize ( ) ;
}
#1386
template < typename _Sseq >
void
seed ( _Sseq & __q )
{
_M_b . seed ( __q ) ;
_M_initialize ( ) ;
}




const _RandomNumberEngine &
base ( ) const noexcept
{ return _M_b ; }




static constexpr result_type
min ( )
{ return _RandomNumberEngine :: min ( ) ; }




static constexpr result_type
max ( )
{ return _RandomNumberEngine :: max ( ) ; }




void
discard ( unsigned long long __z )
{
for ( ; __z != 0ULL ; -- __z )
( * this ) ( ) ;
}




result_type
operator ( ) ( ) ;
#1442
friend bool
operator == ( const shuffle_order_engine & __lhs ,
const shuffle_order_engine & __rhs )
{ return ( __lhs . _M_b == __rhs . _M_b
&& std :: equal ( __lhs . _M_v , __lhs . _M_v + __k , __rhs . _M_v )
&& __lhs . _M_y == __rhs . _M_y ) ; }
#1460
template < typename _RandomNumberEngine1 , size_t __k1 ,
typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: shuffle_order_engine < _RandomNumberEngine1 ,
__k1 > & __x ) ;
#1478
template < typename _RandomNumberEngine1 , size_t __k1 ,
typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: shuffle_order_engine < _RandomNumberEngine1 , __k1 > & __x ) ;

private :
void _M_initialize ( )
{
for ( size_t __i = 0 ; __i < __k ; ++ __i )
_M_v [ __i ] = _M_b ( ) ;
_M_y = _M_b ( ) ;
}

_RandomNumberEngine _M_b ;
result_type _M_v [ __k ] ;
result_type _M_y ;
} ;
#1508
template < typename _RandomNumberEngine , size_t __k >
inline bool
operator != ( const std :: shuffle_order_engine < _RandomNumberEngine ,
__k > & __lhs ,
const std :: shuffle_order_engine < _RandomNumberEngine ,
__k > & __rhs )
{ return ! ( __lhs == __rhs ) ; }





typedef linear_congruential_engine < uint_fast32_t , 16807UL , 0UL , 2147483647UL >
minstd_rand0 ;




typedef linear_congruential_engine < uint_fast32_t , 48271UL , 0UL , 2147483647UL >
minstd_rand ;
#1537
typedef mersenne_twister_engine <
uint_fast32_t ,
32 , 624 , 397 , 31 ,
0x9908b0dfUL , 11 ,
0xffffffffUL , 7 ,
0x9d2c5680UL , 15 ,
0xefc60000UL , 18 , 1812433253UL > mt19937 ;




typedef mersenne_twister_engine <
uint_fast64_t ,
64 , 312 , 156 , 31 ,
0xb5026f5aa96619e9ULL , 29 ,
0x5555555555555555ULL , 17 ,
0x71d67fffeda60000ULL , 37 ,
0xfff7eee000000000ULL , 43 ,
6364136223846793005ULL > mt19937_64 ;

typedef subtract_with_carry_engine < uint_fast32_t , 24 , 10 , 24 >
ranlux24_base ;

typedef subtract_with_carry_engine < uint_fast64_t , 48 , 5 , 12 >
ranlux48_base ;

typedef discard_block_engine < ranlux24_base , 223 , 23 > ranlux24 ;

typedef discard_block_engine < ranlux48_base , 389 , 11 > ranlux48 ;

typedef shuffle_order_engine < minstd_rand0 , 256 > knuth_b ;

typedef minstd_rand0 default_random_engine ;





class random_device
{
public :

typedef unsigned int result_type ;





explicit
random_device ( const std :: string & __token = "default" )
{
_M_init ( __token ) ;
}

~ random_device ( )
{ _M_fini ( ) ; }
#1604
static constexpr result_type
min ( )
{ return std :: numeric_limits < result_type > :: min ( ) ; }

static constexpr result_type
max ( )
{ return std :: numeric_limits < result_type > :: max ( ) ; }

double
entropy ( ) const noexcept
{ return 0.0 ; }

result_type
operator ( ) ( )
{

return this -> _M_getval ( ) ;



}


random_device ( const random_device & ) = delete ;
void operator = ( const random_device & ) = delete ;

private :

void _M_init ( const std :: string & __token ) ;
void _M_init_pretr1 ( const std :: string & __token ) ;
void _M_fini ( ) ;

result_type _M_getval ( ) ;
result_type _M_getval_pretr1 ( ) ;

union
{
FILE * _M_file ;
mt19937 _M_mt ;
} ;
} ;
#1665
template < typename _IntType = int >
class uniform_int_distribution
{
static_assert ( std :: is_integral < _IntType > :: value ,
"template argument not an integral type" ) ;

public :

typedef _IntType result_type ;

struct param_type
{
typedef uniform_int_distribution < _IntType > distribution_type ;

explicit
param_type ( _IntType __a = 0 ,
_IntType __b = std :: numeric_limits < _IntType > :: max ( ) )
: _M_a ( __a ) , _M_b ( __b )
{
;
}

result_type
a ( ) const
{ return _M_a ; }

result_type
b ( ) const
{ return _M_b ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_a == __p2 . _M_a && __p1 . _M_b == __p2 . _M_b ; }

private :
_IntType _M_a ;
_IntType _M_b ;
} ;

public :



explicit
uniform_int_distribution ( _IntType __a = 0 ,
_IntType __b = std :: numeric_limits < _IntType > :: max ( ) )
: _M_param ( __a , __b )
{ }

explicit
uniform_int_distribution ( const param_type & __p )
: _M_param ( __p )
{ }
#1724
void
reset ( ) { }

result_type
a ( ) const
{ return _M_param . a ( ) ; }

result_type
b ( ) const
{ return _M_param . b ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return this -> a ( ) ; }




result_type
max ( ) const
{ return this -> b ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const uniform_int_distribution & __d1 ,
const uniform_int_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _IntType >
inline bool
operator != ( const std :: uniform_int_distribution < _IntType > & __d1 ,
const std :: uniform_int_distribution < _IntType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#1839
template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & ,
const std :: uniform_int_distribution < _IntType > & ) ;
#1853
template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & ,
std :: uniform_int_distribution < _IntType > & ) ;
#1866
template < typename _RealType = double >
class uniform_real_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef uniform_real_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __a = _RealType ( 0 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_a ( __a ) , _M_b ( __b )
{
;
}

result_type
a ( ) const
{ return _M_a ; }

result_type
b ( ) const
{ return _M_b ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_a == __p2 . _M_a && __p1 . _M_b == __p2 . _M_b ; }

private :
_RealType _M_a ;
_RealType _M_b ;
} ;

public :
#1912
explicit
uniform_real_distribution ( _RealType __a = _RealType ( 0 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_param ( __a , __b )
{ }

explicit
uniform_real_distribution ( const param_type & __p )
: _M_param ( __p )
{ }
#1928
void
reset ( ) { }

result_type
a ( ) const
{ return _M_param . a ( ) ; }

result_type
b ( ) const
{ return _M_param . b ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return this -> a ( ) ; }




result_type
max ( ) const
{ return this -> b ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
return ( __aurng ( ) * ( __p . b ( ) - __p . a ( ) ) ) + __p . a ( ) ;
}

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const uniform_real_distribution & __d1 ,
const uniform_real_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _IntType >
inline bool
operator != ( const std :: uniform_real_distribution < _IntType > & __d1 ,
const std :: uniform_real_distribution < _IntType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#2048
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & ,
const std :: uniform_real_distribution < _RealType > & ) ;
#2062
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & ,
std :: uniform_real_distribution < _RealType > & ) ;
#2084
template < typename _RealType = double >
class normal_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef normal_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __mean = _RealType ( 0 ) ,
_RealType __stddev = _RealType ( 1 ) )
: _M_mean ( __mean ) , _M_stddev ( __stddev )
{
;
}

_RealType
mean ( ) const
{ return _M_mean ; }

_RealType
stddev ( ) const
{ return _M_stddev ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return ( __p1 . _M_mean == __p2 . _M_mean
&& __p1 . _M_stddev == __p2 . _M_stddev ) ; }

private :
_RealType _M_mean ;
_RealType _M_stddev ;
} ;

public :




explicit
normal_distribution ( result_type __mean = result_type ( 0 ) ,
result_type __stddev = result_type ( 1 ) )
: _M_param ( __mean , __stddev ) , _M_saved_available ( false )
{ }

explicit
normal_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_saved_available ( false )
{ }




void
reset ( )
{ _M_saved_available = false ; }




_RealType
mean ( ) const
{ return _M_param . mean ( ) ; }




_RealType
stddev ( ) const
{ return _M_param . stddev ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return std :: numeric_limits < result_type > :: lowest ( ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#2230
template < typename _RealType1 >
friend bool
operator == ( const std :: normal_distribution < _RealType1 > & __d1 ,
const std :: normal_distribution < _RealType1 > & __d2 ) ;
#2245
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: normal_distribution < _RealType1 > & __x ) ;
#2260
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: normal_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
result_type _M_saved ;
bool _M_saved_available ;
} ;




template < typename _RealType >
inline bool
operator != ( const std :: normal_distribution < _RealType > & __d1 ,
const std :: normal_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#2297
template < typename _RealType = double >
class lognormal_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef lognormal_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __m = _RealType ( 0 ) ,
_RealType __s = _RealType ( 1 ) )
: _M_m ( __m ) , _M_s ( __s )
{ }

_RealType
m ( ) const
{ return _M_m ; }

_RealType
s ( ) const
{ return _M_s ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_m == __p2 . _M_m && __p1 . _M_s == __p2 . _M_s ; }

private :
_RealType _M_m ;
_RealType _M_s ;
} ;

explicit
lognormal_distribution ( _RealType __m = _RealType ( 0 ) ,
_RealType __s = _RealType ( 1 ) )
: _M_param ( __m , __s ) , _M_nd ( )
{ }

explicit
lognormal_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_nd ( )
{ }




void
reset ( )
{ _M_nd . reset ( ) ; }




_RealType
m ( ) const
{ return _M_param . m ( ) ; }

_RealType
s ( ) const
{ return _M_param . s ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ return std :: exp ( __p . s ( ) * _M_nd ( __urng ) + __p . m ( ) ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#2433
friend bool
operator == ( const lognormal_distribution & __d1 ,
const lognormal_distribution & __d2 )
{ return ( __d1 . _M_param == __d2 . _M_param
&& __d1 . _M_nd == __d2 . _M_nd ) ; }
#2449
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: lognormal_distribution < _RealType1 > & __x ) ;
#2464
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: lognormal_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;

std :: normal_distribution < result_type > _M_nd ;
} ;




template < typename _RealType >
inline bool
operator != ( const std :: lognormal_distribution < _RealType > & __d1 ,
const std :: lognormal_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#2501
template < typename _RealType = double >
class gamma_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef gamma_distribution < _RealType > distribution_type ;
friend class gamma_distribution < _RealType > ;

explicit
param_type ( _RealType __alpha_val = _RealType ( 1 ) ,
_RealType __beta_val = _RealType ( 1 ) )
: _M_alpha ( __alpha_val ) , _M_beta ( __beta_val )
{
;
_M_initialize ( ) ;
}

_RealType
alpha ( ) const
{ return _M_alpha ; }

_RealType
beta ( ) const
{ return _M_beta ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return ( __p1 . _M_alpha == __p2 . _M_alpha
&& __p1 . _M_beta == __p2 . _M_beta ) ; }

private :
void
_M_initialize ( ) ;

_RealType _M_alpha ;
_RealType _M_beta ;

_RealType _M_malpha , _M_a2 ;
} ;

public :




explicit
gamma_distribution ( _RealType __alpha_val = _RealType ( 1 ) ,
_RealType __beta_val = _RealType ( 1 ) )
: _M_param ( __alpha_val , __beta_val ) , _M_nd ( )
{ }

explicit
gamma_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_nd ( )
{ }




void
reset ( )
{ _M_nd . reset ( ) ; }




_RealType
alpha ( ) const
{ return _M_param . alpha ( ) ; }




_RealType
beta ( ) const
{ return _M_param . beta ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#2654
friend bool
operator == ( const gamma_distribution & __d1 ,
const gamma_distribution & __d2 )
{ return ( __d1 . _M_param == __d2 . _M_param
&& __d1 . _M_nd == __d2 . _M_nd ) ; }
#2670
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: gamma_distribution < _RealType1 > & __x ) ;
#2684
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: gamma_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;

std :: normal_distribution < result_type > _M_nd ;
} ;




template < typename _RealType >
inline bool
operator != ( const std :: gamma_distribution < _RealType > & __d1 ,
const std :: gamma_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#2718
template < typename _RealType = double >
class chi_squared_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef chi_squared_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __n = _RealType ( 1 ) )
: _M_n ( __n )
{ }

_RealType
n ( ) const
{ return _M_n ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_n == __p2 . _M_n ; }

private :
_RealType _M_n ;
} ;

explicit
chi_squared_distribution ( _RealType __n = _RealType ( 1 ) )
: _M_param ( __n ) , _M_gd ( __n / 2 )
{ }

explicit
chi_squared_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_gd ( __p . n ( ) / 2 )
{ }




void
reset ( )
{ _M_gd . reset ( ) ; }




_RealType
n ( ) const
{ return _M_param . n ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return 2 * _M_gd ( __urng ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
typedef typename std :: gamma_distribution < result_type > :: param_type
param_type ;
return 2 * _M_gd ( __urng , param_type ( __p . n ( ) / 2 ) ) ;
}

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ typename std :: gamma_distribution < result_type > :: param_type
__p2 ( __p . n ( ) / 2 ) ;
this -> __generate_impl ( __f , __t , __urng , __p2 ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ typename std :: gamma_distribution < result_type > :: param_type
__p2 ( __p . n ( ) / 2 ) ;
this -> __generate_impl ( __f , __t , __urng , __p2 ) ; }
#2857
friend bool
operator == ( const chi_squared_distribution & __d1 ,
const chi_squared_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param && __d1 . _M_gd == __d2 . _M_gd ; }
#2872
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: chi_squared_distribution < _RealType1 > & __x ) ;
#2887
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: chi_squared_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const typename
std :: gamma_distribution < result_type > :: param_type & __p ) ;

param_type _M_param ;

std :: gamma_distribution < result_type > _M_gd ;
} ;




template < typename _RealType >
inline bool
operator != ( const std :: chi_squared_distribution < _RealType > & __d1 ,
const std :: chi_squared_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#2928
template < typename _RealType = double >
class cauchy_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef cauchy_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __a = _RealType ( 0 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_a ( __a ) , _M_b ( __b )
{ }

_RealType
a ( ) const
{ return _M_a ; }

_RealType
b ( ) const
{ return _M_b ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_a == __p2 . _M_a && __p1 . _M_b == __p2 . _M_b ; }

private :
_RealType _M_a ;
_RealType _M_b ;
} ;

explicit
cauchy_distribution ( _RealType __a = _RealType ( 0 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_param ( __a , __b )
{ }

explicit
cauchy_distribution ( const param_type & __p )
: _M_param ( __p )
{ }




void
reset ( )
{ }




_RealType
a ( ) const
{ return _M_param . a ( ) ; }

_RealType
b ( ) const
{ return _M_param . b ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return std :: numeric_limits < result_type > :: lowest ( ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const cauchy_distribution & __d1 ,
const cauchy_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _RealType >
inline bool
operator != ( const std :: cauchy_distribution < _RealType > & __d1 ,
const std :: cauchy_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#3098
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: cauchy_distribution < _RealType > & __x ) ;
#3113
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: cauchy_distribution < _RealType > & __x ) ;
#3129
template < typename _RealType = double >
class fisher_f_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef fisher_f_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __m = _RealType ( 1 ) ,
_RealType __n = _RealType ( 1 ) )
: _M_m ( __m ) , _M_n ( __n )
{ }

_RealType
m ( ) const
{ return _M_m ; }

_RealType
n ( ) const
{ return _M_n ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_m == __p2 . _M_m && __p1 . _M_n == __p2 . _M_n ; }

private :
_RealType _M_m ;
_RealType _M_n ;
} ;

explicit
fisher_f_distribution ( _RealType __m = _RealType ( 1 ) ,
_RealType __n = _RealType ( 1 ) )
: _M_param ( __m , __n ) , _M_gd_x ( __m / 2 ) , _M_gd_y ( __n / 2 )
{ }

explicit
fisher_f_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_gd_x ( __p . m ( ) / 2 ) , _M_gd_y ( __p . n ( ) / 2 )
{ }




void
reset ( )
{
_M_gd_x . reset ( ) ;
_M_gd_y . reset ( ) ;
}




_RealType
m ( ) const
{ return _M_param . m ( ) ; }

_RealType
n ( ) const
{ return _M_param . n ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return ( _M_gd_x ( __urng ) * n ( ) ) / ( _M_gd_y ( __urng ) * m ( ) ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
typedef typename std :: gamma_distribution < result_type > :: param_type
param_type ;
return ( ( _M_gd_x ( __urng , param_type ( __p . m ( ) / 2 ) ) * n ( ) )
/ ( _M_gd_y ( __urng , param_type ( __p . n ( ) / 2 ) ) * m ( ) ) ) ;
}

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#3279
friend bool
operator == ( const fisher_f_distribution & __d1 ,
const fisher_f_distribution & __d2 )
{ return ( __d1 . _M_param == __d2 . _M_param
&& __d1 . _M_gd_x == __d2 . _M_gd_x
&& __d1 . _M_gd_y == __d2 . _M_gd_y ) ; }
#3296
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: fisher_f_distribution < _RealType1 > & __x ) ;
#3311
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: fisher_f_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;

std :: gamma_distribution < result_type > _M_gd_x , _M_gd_y ;
} ;




template < typename _RealType >
inline bool
operator != ( const std :: fisher_f_distribution < _RealType > & __d1 ,
const std :: fisher_f_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#3353
template < typename _RealType = double >
class student_t_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef student_t_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __n = _RealType ( 1 ) )
: _M_n ( __n )
{ }

_RealType
n ( ) const
{ return _M_n ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_n == __p2 . _M_n ; }

private :
_RealType _M_n ;
} ;

explicit
student_t_distribution ( _RealType __n = _RealType ( 1 ) )
: _M_param ( __n ) , _M_nd ( ) , _M_gd ( __n / 2 , 2 )
{ }

explicit
student_t_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_nd ( ) , _M_gd ( __p . n ( ) / 2 , 2 )
{ }




void
reset ( )
{
_M_nd . reset ( ) ;
_M_gd . reset ( ) ;
}




_RealType
n ( ) const
{ return _M_param . n ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return std :: numeric_limits < result_type > :: lowest ( ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return _M_nd ( __urng ) * std :: sqrt ( n ( ) / _M_gd ( __urng ) ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
typedef typename std :: gamma_distribution < result_type > :: param_type
param_type ;

const result_type __g = _M_gd ( __urng , param_type ( __p . n ( ) / 2 , 2 ) ) ;
return _M_nd ( __urng ) * std :: sqrt ( __p . n ( ) / __g ) ;
}

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#3493
friend bool
operator == ( const student_t_distribution & __d1 ,
const student_t_distribution & __d2 )
{ return ( __d1 . _M_param == __d2 . _M_param
&& __d1 . _M_nd == __d2 . _M_nd && __d1 . _M_gd == __d2 . _M_gd ) ; }
#3509
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: student_t_distribution < _RealType1 > & __x ) ;
#3524
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: student_t_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ) ;
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;

std :: normal_distribution < result_type > _M_nd ;
std :: gamma_distribution < result_type > _M_gd ;
} ;




template < typename _RealType >
inline bool
operator != ( const std :: student_t_distribution < _RealType > & __d1 ,
const std :: student_t_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#3572
class bernoulli_distribution
{
public :

typedef bool result_type ;

struct param_type
{
typedef bernoulli_distribution distribution_type ;

explicit
param_type ( double __p = 0.5 )
: _M_p ( __p )
{
;
}

double
p ( ) const
{ return _M_p ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_p == __p2 . _M_p ; }

private :
double _M_p ;
} ;

public :
#3608
explicit
bernoulli_distribution ( double __p = 0.5 )
: _M_param ( __p )
{ }

explicit
bernoulli_distribution ( const param_type & __p )
: _M_param ( __p )
{ }
#3623
void
reset ( ) { }




double
p ( ) const
{ return _M_param . p ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return std :: numeric_limits < result_type > :: min ( ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;
if ( ( __aurng ( ) - __aurng . min ( ) )
< __p . p ( ) * ( __aurng . max ( ) - __aurng . min ( ) ) )
return true ;
return false ;
}

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng , const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const bernoulli_distribution & __d1 ,
const bernoulli_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





inline bool
operator != ( const std :: bernoulli_distribution & __d1 ,
const std :: bernoulli_distribution & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#3743
template < typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: bernoulli_distribution & __x ) ;
#3757
template < typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: bernoulli_distribution & __x )
{
double __p ;
__is >> __p ;
__x . param ( bernoulli_distribution :: param_type ( __p ) ) ;
return __is ;
}
#3776
template < typename _IntType = int >
class binomial_distribution
{
static_assert ( std :: is_integral < _IntType > :: value ,
"template argument not an integral type" ) ;

public :

typedef _IntType result_type ;

struct param_type
{
typedef binomial_distribution < _IntType > distribution_type ;
friend class binomial_distribution < _IntType > ;

explicit
param_type ( _IntType __t = _IntType ( 1 ) , double __p = 0.5 )
: _M_t ( __t ) , _M_p ( __p )
{


;
_M_initialize ( ) ;
}

_IntType
t ( ) const
{ return _M_t ; }

double
p ( ) const
{ return _M_p ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_t == __p2 . _M_t && __p1 . _M_p == __p2 . _M_p ; }

private :
void
_M_initialize ( ) ;

_IntType _M_t ;
double _M_p ;

double _M_q ;

double _M_d1 , _M_d2 , _M_s1 , _M_s2 , _M_c ,
_M_a1 , _M_a123 , _M_s , _M_lf , _M_lp1p ;

bool _M_easy ;
} ;


explicit
binomial_distribution ( _IntType __t = _IntType ( 1 ) ,
double __p = 0.5 )
: _M_param ( __t , __p ) , _M_nd ( )
{ }

explicit
binomial_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_nd ( )
{ }




void
reset ( )
{ _M_nd . reset ( ) ; }




_IntType
t ( ) const
{ return _M_param . t ( ) ; }




double
p ( ) const
{ return _M_param . p ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return 0 ; }




result_type
max ( ) const
{ return _M_param . t ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#3930
friend bool
operator == ( const binomial_distribution & __d1 ,
const binomial_distribution & __d2 )

{ return __d1 . _M_param == __d2 . _M_param && __d1 . _M_nd == __d2 . _M_nd ; }
#3949
template < typename _IntType1 ,
typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: binomial_distribution < _IntType1 > & __x ) ;
#3965
template < typename _IntType1 ,
typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: binomial_distribution < _IntType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _UniformRandomNumberGenerator >
result_type
_M_waiting ( _UniformRandomNumberGenerator & __urng ,
_IntType __t , double __q ) ;

param_type _M_param ;


std :: normal_distribution < double > _M_nd ;
} ;




template < typename _IntType >
inline bool
operator != ( const std :: binomial_distribution < _IntType > & __d1 ,
const std :: binomial_distribution < _IntType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#4007
template < typename _IntType = int >
class geometric_distribution
{
static_assert ( std :: is_integral < _IntType > :: value ,
"template argument not an integral type" ) ;

public :

typedef _IntType result_type ;

struct param_type
{
typedef geometric_distribution < _IntType > distribution_type ;
friend class geometric_distribution < _IntType > ;

explicit
param_type ( double __p = 0.5 )
: _M_p ( __p )
{
;
_M_initialize ( ) ;
}

double
p ( ) const
{ return _M_p ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_p == __p2 . _M_p ; }

private :
void
_M_initialize ( )
{ _M_log_1_p = std :: log ( 1.0 - _M_p ) ; }

double _M_p ;

double _M_log_1_p ;
} ;


explicit
geometric_distribution ( double __p = 0.5 )
: _M_param ( __p )
{ }

explicit
geometric_distribution ( const param_type & __p )
: _M_param ( __p )
{ }
#4064
void
reset ( ) { }




double
p ( ) const
{ return _M_param . p ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return 0 ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const geometric_distribution & __d1 ,
const geometric_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _IntType >
inline bool
operator != ( const std :: geometric_distribution < _IntType > & __d1 ,
const std :: geometric_distribution < _IntType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#4178
template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: geometric_distribution < _IntType > & __x ) ;
#4193
template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: geometric_distribution < _IntType > & __x ) ;
#4207
template < typename _IntType = int >
class negative_binomial_distribution
{
static_assert ( std :: is_integral < _IntType > :: value ,
"template argument not an integral type" ) ;

public :

typedef _IntType result_type ;

struct param_type
{
typedef negative_binomial_distribution < _IntType > distribution_type ;

explicit
param_type ( _IntType __k = 1 , double __p = 0.5 )
: _M_k ( __k ) , _M_p ( __p )
{
;
}

_IntType
k ( ) const
{ return _M_k ; }

double
p ( ) const
{ return _M_p ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_k == __p2 . _M_k && __p1 . _M_p == __p2 . _M_p ; }

private :
_IntType _M_k ;
double _M_p ;
} ;

explicit
negative_binomial_distribution ( _IntType __k = 1 , double __p = 0.5 )
: _M_param ( __k , __p ) , _M_gd ( __k , ( 1.0 - __p ) / __p )
{ }

explicit
negative_binomial_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_gd ( __p . k ( ) , ( 1.0 - __p . p ( ) ) / __p . p ( ) )
{ }




void
reset ( )
{ _M_gd . reset ( ) ; }




_IntType
k ( ) const
{ return _M_param . k ( ) ; }




double
p ( ) const
{ return _M_param . p ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ) ;

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate_impl ( __f , __t , __urng ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#4350
friend bool
operator == ( const negative_binomial_distribution & __d1 ,
const negative_binomial_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param && __d1 . _M_gd == __d2 . _M_gd ; }
#4366
template < typename _IntType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: negative_binomial_distribution < _IntType1 > & __x ) ;
#4381
template < typename _IntType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: negative_binomial_distribution < _IntType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ) ;
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;

std :: gamma_distribution < double > _M_gd ;
} ;




template < typename _IntType >
inline bool
operator != ( const std :: negative_binomial_distribution < _IntType > & __d1 ,
const std :: negative_binomial_distribution < _IntType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#4429
template < typename _IntType = int >
class poisson_distribution
{
static_assert ( std :: is_integral < _IntType > :: value ,
"template argument not an integral type" ) ;

public :

typedef _IntType result_type ;

struct param_type
{
typedef poisson_distribution < _IntType > distribution_type ;
friend class poisson_distribution < _IntType > ;

explicit
param_type ( double __mean = 1.0 )
: _M_mean ( __mean )
{
;
_M_initialize ( ) ;
}

double
mean ( ) const
{ return _M_mean ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_mean == __p2 . _M_mean ; }

private :

void
_M_initialize ( ) ;

double _M_mean ;

double _M_lm_thr ;

double _M_lfm , _M_sm , _M_d , _M_scx , _M_1cx , _M_c2b , _M_cb ;

} ;


explicit
poisson_distribution ( double __mean = 1.0 )
: _M_param ( __mean ) , _M_nd ( )
{ }

explicit
poisson_distribution ( const param_type & __p )
: _M_param ( __p ) , _M_nd ( )
{ }




void
reset ( )
{ _M_nd . reset ( ) ; }




double
mean ( ) const
{ return _M_param . mean ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return 0 ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }
#4567
friend bool
operator == ( const poisson_distribution & __d1 ,
const poisson_distribution & __d2 )

{ return __d1 . _M_param == __d2 . _M_param && __d1 . _M_nd == __d2 . _M_nd ; }
#4586
template < typename _IntType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: poisson_distribution < _IntType1 > & __x ) ;
#4601
template < typename _IntType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: poisson_distribution < _IntType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;


std :: normal_distribution < double > _M_nd ;
} ;




template < typename _IntType >
inline bool
operator != ( const std :: poisson_distribution < _IntType > & __d1 ,
const std :: poisson_distribution < _IntType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#4645
template < typename _RealType = double >
class exponential_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef exponential_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __lambda = _RealType ( 1 ) )
: _M_lambda ( __lambda )
{
;
}

_RealType
lambda ( ) const
{ return _M_lambda ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_lambda == __p2 . _M_lambda ; }

private :
_RealType _M_lambda ;
} ;

public :




explicit
exponential_distribution ( const result_type & __lambda = result_type ( 1 ) )
: _M_param ( __lambda )
{ }

explicit
exponential_distribution ( const param_type & __p )
: _M_param ( __p )
{ }
#4698
void
reset ( ) { }




_RealType
lambda ( ) const
{ return _M_param . lambda ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
return - std :: log ( result_type ( 1 ) - __aurng ( ) ) / __p . lambda ( ) ;
}

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const exponential_distribution & __d1 ,
const exponential_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _RealType >
inline bool
operator != ( const std :: exponential_distribution < _RealType > & __d1 ,
const std :: exponential_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#4817
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: exponential_distribution < _RealType > & __x ) ;
#4832
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: exponential_distribution < _RealType > & __x ) ;
#4847
template < typename _RealType = double >
class weibull_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef weibull_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __a = _RealType ( 1 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_a ( __a ) , _M_b ( __b )
{ }

_RealType
a ( ) const
{ return _M_a ; }

_RealType
b ( ) const
{ return _M_b ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_a == __p2 . _M_a && __p1 . _M_b == __p2 . _M_b ; }

private :
_RealType _M_a ;
_RealType _M_b ;
} ;

explicit
weibull_distribution ( _RealType __a = _RealType ( 1 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_param ( __a , __b )
{ }

explicit
weibull_distribution ( const param_type & __p )
: _M_param ( __p )
{ }




void
reset ( )
{ }




_RealType
a ( ) const
{ return _M_param . a ( ) ; }




_RealType
b ( ) const
{ return _M_param . b ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const weibull_distribution & __d1 ,
const weibull_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _RealType >
inline bool
operator != ( const std :: weibull_distribution < _RealType > & __d1 ,
const std :: weibull_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#5020
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: weibull_distribution < _RealType > & __x ) ;
#5035
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: weibull_distribution < _RealType > & __x ) ;
#5050
template < typename _RealType = double >
class extreme_value_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef extreme_value_distribution < _RealType > distribution_type ;

explicit
param_type ( _RealType __a = _RealType ( 0 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_a ( __a ) , _M_b ( __b )
{ }

_RealType
a ( ) const
{ return _M_a ; }

_RealType
b ( ) const
{ return _M_b ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_a == __p2 . _M_a && __p1 . _M_b == __p2 . _M_b ; }

private :
_RealType _M_a ;
_RealType _M_b ;
} ;

explicit
extreme_value_distribution ( _RealType __a = _RealType ( 0 ) ,
_RealType __b = _RealType ( 1 ) )
: _M_param ( __a , __b )
{ }

explicit
extreme_value_distribution ( const param_type & __p )
: _M_param ( __p )
{ }




void
reset ( )
{ }




_RealType
a ( ) const
{ return _M_param . a ( ) ; }




_RealType
b ( ) const
{ return _M_param . b ( ) ; }




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return std :: numeric_limits < result_type > :: lowest ( ) ; }




result_type
max ( ) const
{ return std :: numeric_limits < result_type > :: max ( ) ; }




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const extreme_value_distribution & __d1 ,
const extreme_value_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _RealType >
inline bool
operator != ( const std :: extreme_value_distribution < _RealType > & __d1 ,
const std :: extreme_value_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#5223
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: extreme_value_distribution < _RealType > & __x ) ;
#5238
template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: extreme_value_distribution < _RealType > & __x ) ;
#5250
template < typename _IntType = int >
class discrete_distribution
{
static_assert ( std :: is_integral < _IntType > :: value ,
"template argument not an integral type" ) ;

public :

typedef _IntType result_type ;

struct param_type
{
typedef discrete_distribution < _IntType > distribution_type ;
friend class discrete_distribution < _IntType > ;

param_type ( )
: _M_prob ( ) , _M_cp ( )
{ }

template < typename _InputIterator >
param_type ( _InputIterator __wbegin ,
_InputIterator __wend )
: _M_prob ( __wbegin , __wend ) , _M_cp ( )
{ _M_initialize ( ) ; }

param_type ( initializer_list < double > __wil )
: _M_prob ( __wil . begin ( ) , __wil . end ( ) ) , _M_cp ( )
{ _M_initialize ( ) ; }

template < typename _Func >
param_type ( size_t __nw , double __xmin , double __xmax ,
_Func __fw ) ;


param_type ( const param_type & ) = default ;
param_type & operator = ( const param_type & ) = default ;

std :: vector < double >
probabilities ( ) const
{ return _M_prob . empty ( ) ? std :: vector < double > ( 1 , 1.0 ) : _M_prob ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_prob == __p2 . _M_prob ; }

private :
void
_M_initialize ( ) ;

std :: vector < double > _M_prob ;
std :: vector < double > _M_cp ;
} ;

discrete_distribution ( )
: _M_param ( )
{ }

template < typename _InputIterator >
discrete_distribution ( _InputIterator __wbegin ,
_InputIterator __wend )
: _M_param ( __wbegin , __wend )
{ }

discrete_distribution ( initializer_list < double > __wl )
: _M_param ( __wl )
{ }

template < typename _Func >
discrete_distribution ( size_t __nw , double __xmin , double __xmax ,
_Func __fw )
: _M_param ( __nw , __xmin , __xmax , __fw )
{ }

explicit
discrete_distribution ( const param_type & __p )
: _M_param ( __p )
{ }




void
reset ( )
{ }




std :: vector < double >
probabilities ( ) const
{
return _M_param . _M_prob . empty ( )
? std :: vector < double > ( 1 , 1.0 ) : _M_param . _M_prob ;
}




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{ return result_type ( 0 ) ; }




result_type
max ( ) const
{
return _M_param . _M_prob . empty ( )
? result_type ( 0 ) : result_type ( _M_param . _M_prob . size ( ) - 1 ) ;
}




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const discrete_distribution & __d1 ,
const discrete_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }
#5431
template < typename _IntType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: discrete_distribution < _IntType1 > & __x ) ;
#5447
template < typename _IntType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: discrete_distribution < _IntType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _IntType >
inline bool
operator != ( const std :: discrete_distribution < _IntType > & __d1 ,
const std :: discrete_distribution < _IntType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#5480
template < typename _RealType = double >
class piecewise_constant_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef piecewise_constant_distribution < _RealType > distribution_type ;
friend class piecewise_constant_distribution < _RealType > ;

param_type ( )
: _M_int ( ) , _M_den ( ) , _M_cp ( )
{ }

template < typename _InputIteratorB , typename _InputIteratorW >
param_type ( _InputIteratorB __bfirst ,
_InputIteratorB __bend ,
_InputIteratorW __wbegin ) ;

template < typename _Func >
param_type ( initializer_list < _RealType > __bi , _Func __fw ) ;

template < typename _Func >
param_type ( size_t __nw , _RealType __xmin , _RealType __xmax ,
_Func __fw ) ;


param_type ( const param_type & ) = default ;
param_type & operator = ( const param_type & ) = default ;

std :: vector < _RealType >
intervals ( ) const
{
if ( _M_int . empty ( ) )
{
std :: vector < _RealType > __tmp ( 2 ) ;
__tmp [ 1 ] = _RealType ( 1 ) ;
return __tmp ;
}
else
return _M_int ;
}

std :: vector < double >
densities ( ) const
{ return _M_den . empty ( ) ? std :: vector < double > ( 1 , 1.0 ) : _M_den ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return __p1 . _M_int == __p2 . _M_int && __p1 . _M_den == __p2 . _M_den ; }

private :
void
_M_initialize ( ) ;

std :: vector < _RealType > _M_int ;
std :: vector < double > _M_den ;
std :: vector < double > _M_cp ;
} ;

explicit
piecewise_constant_distribution ( )
: _M_param ( )
{ }

template < typename _InputIteratorB , typename _InputIteratorW >
piecewise_constant_distribution ( _InputIteratorB __bfirst ,
_InputIteratorB __bend ,
_InputIteratorW __wbegin )
: _M_param ( __bfirst , __bend , __wbegin )
{ }

template < typename _Func >
piecewise_constant_distribution ( initializer_list < _RealType > __bl ,
_Func __fw )
: _M_param ( __bl , __fw )
{ }

template < typename _Func >
piecewise_constant_distribution ( size_t __nw ,
_RealType __xmin , _RealType __xmax ,
_Func __fw )
: _M_param ( __nw , __xmin , __xmax , __fw )
{ }

explicit
piecewise_constant_distribution ( const param_type & __p )
: _M_param ( __p )
{ }




void
reset ( )
{ }




std :: vector < _RealType >
intervals ( ) const
{
if ( _M_param . _M_int . empty ( ) )
{
std :: vector < _RealType > __tmp ( 2 ) ;
__tmp [ 1 ] = _RealType ( 1 ) ;
return __tmp ;
}
else
return _M_param . _M_int ;
}




std :: vector < double >
densities ( ) const
{
return _M_param . _M_den . empty ( )
? std :: vector < double > ( 1 , 1.0 ) : _M_param . _M_den ;
}




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{
return _M_param . _M_int . empty ( )
? result_type ( 0 ) : _M_param . _M_int . front ( ) ;
}




result_type
max ( ) const
{
return _M_param . _M_int . empty ( )
? result_type ( 1 ) : _M_param . _M_int . back ( ) ;
}




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const piecewise_constant_distribution & __d1 ,
const piecewise_constant_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }
#5698
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: piecewise_constant_distribution < _RealType1 > & __x ) ;
#5714
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: piecewise_constant_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _RealType >
inline bool
operator != ( const std :: piecewise_constant_distribution < _RealType > & __d1 ,
const std :: piecewise_constant_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#5747
template < typename _RealType = double >
class piecewise_linear_distribution
{
static_assert ( std :: is_floating_point < _RealType > :: value ,
"template argument not a floating point type" ) ;

public :

typedef _RealType result_type ;

struct param_type
{
typedef piecewise_linear_distribution < _RealType > distribution_type ;
friend class piecewise_linear_distribution < _RealType > ;

param_type ( )
: _M_int ( ) , _M_den ( ) , _M_cp ( ) , _M_m ( )
{ }

template < typename _InputIteratorB , typename _InputIteratorW >
param_type ( _InputIteratorB __bfirst ,
_InputIteratorB __bend ,
_InputIteratorW __wbegin ) ;

template < typename _Func >
param_type ( initializer_list < _RealType > __bl , _Func __fw ) ;

template < typename _Func >
param_type ( size_t __nw , _RealType __xmin , _RealType __xmax ,
_Func __fw ) ;


param_type ( const param_type & ) = default ;
param_type & operator = ( const param_type & ) = default ;

std :: vector < _RealType >
intervals ( ) const
{
if ( _M_int . empty ( ) )
{
std :: vector < _RealType > __tmp ( 2 ) ;
__tmp [ 1 ] = _RealType ( 1 ) ;
return __tmp ;
}
else
return _M_int ;
}

std :: vector < double >
densities ( ) const
{ return _M_den . empty ( ) ? std :: vector < double > ( 2 , 1.0 ) : _M_den ; }

friend bool
operator == ( const param_type & __p1 , const param_type & __p2 )
{ return ( __p1 . _M_int == __p2 . _M_int
&& __p1 . _M_den == __p2 . _M_den ) ; }

private :
void
_M_initialize ( ) ;

std :: vector < _RealType > _M_int ;
std :: vector < double > _M_den ;
std :: vector < double > _M_cp ;
std :: vector < double > _M_m ;
} ;

explicit
piecewise_linear_distribution ( )
: _M_param ( )
{ }

template < typename _InputIteratorB , typename _InputIteratorW >
piecewise_linear_distribution ( _InputIteratorB __bfirst ,
_InputIteratorB __bend ,
_InputIteratorW __wbegin )
: _M_param ( __bfirst , __bend , __wbegin )
{ }

template < typename _Func >
piecewise_linear_distribution ( initializer_list < _RealType > __bl ,
_Func __fw )
: _M_param ( __bl , __fw )
{ }

template < typename _Func >
piecewise_linear_distribution ( size_t __nw ,
_RealType __xmin , _RealType __xmax ,
_Func __fw )
: _M_param ( __nw , __xmin , __xmax , __fw )
{ }

explicit
piecewise_linear_distribution ( const param_type & __p )
: _M_param ( __p )
{ }




void
reset ( )
{ }




std :: vector < _RealType >
intervals ( ) const
{
if ( _M_param . _M_int . empty ( ) )
{
std :: vector < _RealType > __tmp ( 2 ) ;
__tmp [ 1 ] = _RealType ( 1 ) ;
return __tmp ;
}
else
return _M_param . _M_int ;
}





std :: vector < double >
densities ( ) const
{
return _M_param . _M_den . empty ( )
? std :: vector < double > ( 2 , 1.0 ) : _M_param . _M_den ;
}




param_type
param ( ) const
{ return _M_param ; }





void
param ( const param_type & __param )
{ _M_param = __param ; }




result_type
min ( ) const
{
return _M_param . _M_int . empty ( )
? result_type ( 0 ) : _M_param . _M_int . front ( ) ;
}




result_type
max ( ) const
{
return _M_param . _M_int . empty ( )
? result_type ( 1 ) : _M_param . _M_int . back ( ) ;
}




template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{ return this -> operator ( ) ( __urng , _M_param ) ; }

template < typename _UniformRandomNumberGenerator >
result_type
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{ this -> __generate ( __f , __t , __urng , _M_param ) ; }

template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }

template < typename _UniformRandomNumberGenerator >
void
__generate ( result_type * __f , result_type * __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{ this -> __generate_impl ( __f , __t , __urng , __p ) ; }





friend bool
operator == ( const piecewise_linear_distribution & __d1 ,
const piecewise_linear_distribution & __d2 )
{ return __d1 . _M_param == __d2 . _M_param ; }
#5968
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const std :: piecewise_linear_distribution < _RealType1 > & __x ) ;
#5984
template < typename _RealType1 , typename _CharT , typename _Traits >
friend std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
std :: piecewise_linear_distribution < _RealType1 > & __x ) ;

private :
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p ) ;

param_type _M_param ;
} ;





template < typename _RealType >
inline bool
operator != ( const std :: piecewise_linear_distribution < _RealType > & __d1 ,
const std :: piecewise_linear_distribution < _RealType > & __d2 )
{ return ! ( __d1 == __d2 ) ; }
#6025
class seed_seq
{

public :

typedef uint_least32_t result_type ;


seed_seq ( )
: _M_v ( )
{ }

template < typename _IntType >
seed_seq ( std :: initializer_list < _IntType > il ) ;

template < typename _InputIterator >
seed_seq ( _InputIterator __begin , _InputIterator __end ) ;


template < typename _RandomAccessIterator >
void
generate ( _RandomAccessIterator __begin , _RandomAccessIterator __end ) ;


size_t size ( ) const
{ return _M_v . size ( ) ; }

template < typename OutputIterator >
void
param ( OutputIterator __dest ) const
{ std :: copy ( _M_v . begin ( ) , _M_v . end ( ) , __dest ) ; }

private :

std :: vector < result_type > _M_v ;
} ;
#6067
}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/opt_random.h"
#33
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/random.tcc"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/numeric"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_numeric.h"
#65
namespace std
{
#80
template < typename _ForwardIterator , typename _Tp >
void
iota ( _ForwardIterator __first , _ForwardIterator __last , _Tp __value )
{





;

for ( ; __first != __last ; ++ __first )
{
* __first = __value ;
++ __value ;
}
}


}



namespace std
{
#118
template < typename _InputIterator , typename _Tp >
inline _Tp
accumulate ( _InputIterator __first , _InputIterator __last , _Tp __init )
{


;

for ( ; __first != __last ; ++ __first )
__init = __init + * __first ;
return __init ;
}
#144
template < typename _InputIterator , typename _Tp , typename _BinaryOperation >
inline _Tp
accumulate ( _InputIterator __first , _InputIterator __last , _Tp __init ,
_BinaryOperation __binary_op )
{


;

for ( ; __first != __last ; ++ __first )
__init = __binary_op ( __init , * __first ) ;
return __init ;
}
#172
template < typename _InputIterator1 , typename _InputIterator2 , typename _Tp >
inline _Tp
inner_product ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _Tp __init )
{



;

for ( ; __first1 != __last1 ; ++ __first1 , ++ __first2 )
__init = __init + ( * __first1 * * __first2 ) ;
return __init ;
}
#203
template < typename _InputIterator1 , typename _InputIterator2 , typename _Tp ,
typename _BinaryOperation1 , typename _BinaryOperation2 >
inline _Tp
inner_product ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _Tp __init ,
_BinaryOperation1 __binary_op1 ,
_BinaryOperation2 __binary_op2 )
{



;

for ( ; __first1 != __last1 ; ++ __first1 , ++ __first2 )
__init = __binary_op1 ( __init , __binary_op2 ( * __first1 , * __first2 ) ) ;
return __init ;
}
#235
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 ;
_ValueType __value = * __first ;
* __result = __value ;
while ( ++ __first != __last )
{
__value = __value + * __first ;
* ++ __result = __value ;
}
return ++ __result ;
}
#275
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 ;
_ValueType __value = * __first ;
* __result = __value ;
while ( ++ __first != __last )
{
__value = __binary_op ( __value , * __first ) ;
* ++ __result = __value ;
}
return ++ __result ;
}
#315
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 ;
_ValueType __value = * __first ;
* __result = __value ;
while ( ++ __first != __last )
{
_ValueType __tmp = * __first ;
* ++ __result = __tmp - __value ;
__value = std :: move ( __tmp ) ;
}
return ++ __result ;
}
#357
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 ;
_ValueType __value = * __first ;
* __result = __value ;
while ( ++ __first != __last )
{
_ValueType __tmp = * __first ;
* ++ __result = __binary_op ( __tmp , __value ) ;
__value = std :: move ( __tmp ) ;
}
return ++ __result ;
}


}
#35 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/random.tcc"
namespace std
{



namespace __detail
{
#50
template < typename _Tp , _Tp __m , _Tp __a , _Tp __c >
_Tp
_Mod < _Tp , __m , __a , __c , false , true > ::
__calc ( _Tp __x )
{
if ( __a == 1 )
__x %= __m ;
else
{
static const _Tp __q = __m / __a ;
static const _Tp __r = __m % __a ;

_Tp __t1 = __a * ( __x % __q ) ;
_Tp __t2 = __r * ( __x / __q ) ;
if ( __t1 >= __t2 )
__x = __t1 - __t2 ;
else
__x = __m - __t2 + __t1 ;
}

if ( __c != 0 )
{
const _Tp __d = __m - __x ;
if ( __d > __c )
__x += __c ;
else
__x = __c - __d ;
}
return __x ;
}

template < typename _InputIterator , typename _OutputIterator ,
typename _Tp >
_OutputIterator
__normalize ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result , const _Tp & __factor )
{
for ( ; __first != __last ; ++ __first , ++ __result )
* __result = * __first / __factor ;
return __result ;
}


}



template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
constexpr _UIntType
linear_congruential_engine < _UIntType , __a , __c , __m > :: multiplier ;

template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
constexpr _UIntType
linear_congruential_engine < _UIntType , __a , __c , __m > :: increment ;

template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
constexpr _UIntType
linear_congruential_engine < _UIntType , __a , __c , __m > :: modulus ;

template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
constexpr _UIntType
linear_congruential_engine < _UIntType , __a , __c , __m > :: default_seed ;





template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
void
linear_congruential_engine < _UIntType , __a , __c , __m > ::
seed ( result_type __s )
{
if ( ( __detail :: __mod < _UIntType , __m > ( __c ) == 0 )
&& ( __detail :: __mod < _UIntType , __m > ( __s ) == 0 ) )
_M_x = 1 ;
else
_M_x = __detail :: __mod < _UIntType , __m > ( __s ) ;
}




template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m >
template < typename _Sseq >
typename std :: enable_if < std :: is_class < _Sseq > :: value > :: type
linear_congruential_engine < _UIntType , __a , __c , __m > ::
seed ( _Sseq & __q )
{
const _UIntType __k0 = __m == 0 ? std :: numeric_limits < _UIntType > :: digits
: std :: __lg ( __m ) ;
const _UIntType __k = ( __k0 + 31 ) / 32 ;
uint_least32_t __arr [ __k + 3 ] ;
__q . generate ( __arr + 0 , __arr + __k + 3 ) ;
_UIntType __factor = 1u ;
_UIntType __sum = 0u ;
for ( size_t __j = 0 ; __j < __k ; ++ __j )
{
__sum += __arr [ __j + 3 ] * __factor ;
__factor *= __detail :: _Shift < _UIntType , 32 > :: __value ;
}
seed ( __sum ) ;
}

template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const linear_congruential_engine < _UIntType ,
__a , __c , __m > & __lcr )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
__os . flags ( __ios_base :: dec | __ios_base :: fixed | __ios_base :: left ) ;
__os . fill ( __os . widen ( ' ' ) ) ;

__os << __lcr . _M_x ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
return __os ;
}

template < typename _UIntType , _UIntType __a , _UIntType __c , _UIntType __m ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
linear_congruential_engine < _UIntType , __a , __c , __m > & __lcr )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec ) ;

__is >> __lcr . _M_x ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: word_size ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: state_size ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: shift_size ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: mask_bits ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr _UIntType
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: xor_mask ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: tempering_u ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr _UIntType
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: tempering_d ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: tempering_s ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr _UIntType
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: tempering_b ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: tempering_t ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr _UIntType
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: tempering_c ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr size_t
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: tempering_l ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr _UIntType
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > ::
initialization_multiplier ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
constexpr _UIntType
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: default_seed ;

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
void
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > ::
seed ( result_type __sd )
{
_M_x [ 0 ] = __detail :: __mod < _UIntType ,
__detail :: _Shift < _UIntType , __w > :: __value > ( __sd ) ;

for ( size_t __i = 1 ; __i < state_size ; ++ __i )
{
_UIntType __x = _M_x [ __i - 1 ] ;
__x ^= __x >> ( __w - 2 ) ;
__x *= __f ;
__x += __detail :: __mod < _UIntType , __n > ( __i ) ;
_M_x [ __i ] = __detail :: __mod < _UIntType ,
__detail :: _Shift < _UIntType , __w > :: __value > ( __x ) ;
}
_M_p = state_size ;
}

template < typename _UIntType ,
size_t __w , size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
template < typename _Sseq >
typename std :: enable_if < std :: is_class < _Sseq > :: value > :: type
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > ::
seed ( _Sseq & __q )
{
const _UIntType __upper_mask = ( ~ _UIntType ( ) ) << __r ;
const size_t __k = ( __w + 31 ) / 32 ;
uint_least32_t __arr [ __n * __k ] ;
__q . generate ( __arr + 0 , __arr + __n * __k ) ;

bool __zero = true ;
for ( size_t __i = 0 ; __i < state_size ; ++ __i )
{
_UIntType __factor = 1u ;
_UIntType __sum = 0u ;
for ( size_t __j = 0 ; __j < __k ; ++ __j )
{
__sum += __arr [ __k * __i + __j ] * __factor ;
__factor *= __detail :: _Shift < _UIntType , 32 > :: __value ;
}
_M_x [ __i ] = __detail :: __mod < _UIntType ,
__detail :: _Shift < _UIntType , __w > :: __value > ( __sum ) ;

if ( __zero )
{
if ( __i == 0 )
{
if ( ( _M_x [ 0 ] & __upper_mask ) != 0u )
__zero = false ;
}
else if ( _M_x [ __i ] != 0u )
__zero = false ;
}
}
if ( __zero )
_M_x [ 0 ] = __detail :: _Shift < _UIntType , __w - 1 > :: __value ;
_M_p = state_size ;
}

template < typename _UIntType , size_t __w ,
size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
void
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > ::
_M_gen_rand ( void )
{
const _UIntType __upper_mask = ( ~ _UIntType ( ) ) << __r ;
const _UIntType __lower_mask = ~ __upper_mask ;

for ( size_t __k = 0 ; __k < ( __n - __m ) ; ++ __k )
{
_UIntType __y = ( ( _M_x [ __k ] & __upper_mask )
| ( _M_x [ __k + 1 ] & __lower_mask ) ) ;
_M_x [ __k ] = ( _M_x [ __k + __m ] ^ ( __y >> 1 )
^ ( ( __y & 0x01 ) ? __a : 0 ) ) ;
}

for ( size_t __k = ( __n - __m ) ; __k < ( __n - 1 ) ; ++ __k )
{
_UIntType __y = ( ( _M_x [ __k ] & __upper_mask )
| ( _M_x [ __k + 1 ] & __lower_mask ) ) ;
_M_x [ __k ] = ( _M_x [ __k + ( __m - __n ) ] ^ ( __y >> 1 )
^ ( ( __y & 0x01 ) ? __a : 0 ) ) ;
}

_UIntType __y = ( ( _M_x [ __n - 1 ] & __upper_mask )
| ( _M_x [ 0 ] & __lower_mask ) ) ;
_M_x [ __n - 1 ] = ( _M_x [ __m - 1 ] ^ ( __y >> 1 )
^ ( ( __y & 0x01 ) ? __a : 0 ) ) ;
_M_p = 0 ;
}

template < typename _UIntType , size_t __w ,
size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
void
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > ::
discard ( unsigned long long __z )
{
while ( __z > state_size - _M_p )
{
__z -= state_size - _M_p ;
_M_gen_rand ( ) ;
}
_M_p += __z ;
}

template < typename _UIntType , size_t __w ,
size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f >
typename
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > :: result_type
mersenne_twister_engine < _UIntType , __w , __n , __m , __r , __a , __u , __d ,
__s , __b , __t , __c , __l , __f > ::
operator ( ) ( )
{

if ( _M_p >= state_size )
_M_gen_rand ( ) ;


result_type __z = _M_x [ _M_p ++ ] ;
__z ^= ( __z >> __u ) & __d ;
__z ^= ( __z << __s ) & __b ;
__z ^= ( __z << __t ) & __c ;
__z ^= ( __z >> __l ) ;

return __z ;
}

template < typename _UIntType , size_t __w ,
size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const mersenne_twister_engine < _UIntType , __w , __n , __m ,
__r , __a , __u , __d , __s , __b , __t , __c , __l , __f > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: dec | __ios_base :: fixed | __ios_base :: left ) ;
__os . fill ( __space ) ;

for ( size_t __i = 0 ; __i < __n ; ++ __i )
__os << __x . _M_x [ __i ] << __space ;
__os << __x . _M_p ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
return __os ;
}

template < typename _UIntType , size_t __w ,
size_t __n , size_t __m , size_t __r ,
_UIntType __a , size_t __u , _UIntType __d , size_t __s ,
_UIntType __b , size_t __t , _UIntType __c , size_t __l ,
_UIntType __f , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
mersenne_twister_engine < _UIntType , __w , __n , __m ,
__r , __a , __u , __d , __s , __b , __t , __c , __l , __f > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

for ( size_t __i = 0 ; __i < __n ; ++ __i )
__is >> __x . _M_x [ __i ] ;
__is >> __x . _M_p ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _UIntType , size_t __w , size_t __s , size_t __r >
constexpr size_t
subtract_with_carry_engine < _UIntType , __w , __s , __r > :: word_size ;

template < typename _UIntType , size_t __w , size_t __s , size_t __r >
constexpr size_t
subtract_with_carry_engine < _UIntType , __w , __s , __r > :: short_lag ;

template < typename _UIntType , size_t __w , size_t __s , size_t __r >
constexpr size_t
subtract_with_carry_engine < _UIntType , __w , __s , __r > :: long_lag ;

template < typename _UIntType , size_t __w , size_t __s , size_t __r >
constexpr _UIntType
subtract_with_carry_engine < _UIntType , __w , __s , __r > :: default_seed ;

template < typename _UIntType , size_t __w , size_t __s , size_t __r >
void
subtract_with_carry_engine < _UIntType , __w , __s , __r > ::
seed ( result_type __value )
{
std :: linear_congruential_engine < result_type , 40014u , 0u , 2147483563u >
__lcg ( __value == 0u ? default_seed : __value ) ;

const size_t __n = ( __w + 31 ) / 32 ;

for ( size_t __i = 0 ; __i < long_lag ; ++ __i )
{
_UIntType __sum = 0u ;
_UIntType __factor = 1u ;
for ( size_t __j = 0 ; __j < __n ; ++ __j )
{
__sum += __detail :: __mod < uint_least32_t ,
__detail :: _Shift < uint_least32_t , 32 > :: __value >
( __lcg ( ) ) * __factor ;
__factor *= __detail :: _Shift < _UIntType , 32 > :: __value ;
}
_M_x [ __i ] = __detail :: __mod < _UIntType ,
__detail :: _Shift < _UIntType , __w > :: __value > ( __sum ) ;
}
_M_carry = ( _M_x [ long_lag - 1 ] == 0 ) ? 1 : 0 ;
_M_p = 0 ;
}

template < typename _UIntType , size_t __w , size_t __s , size_t __r >
template < typename _Sseq >
typename std :: enable_if < std :: is_class < _Sseq > :: value > :: type
subtract_with_carry_engine < _UIntType , __w , __s , __r > ::
seed ( _Sseq & __q )
{
const size_t __k = ( __w + 31 ) / 32 ;
uint_least32_t __arr [ __r * __k ] ;
__q . generate ( __arr + 0 , __arr + __r * __k ) ;

for ( size_t __i = 0 ; __i < long_lag ; ++ __i )
{
_UIntType __sum = 0u ;
_UIntType __factor = 1u ;
for ( size_t __j = 0 ; __j < __k ; ++ __j )
{
__sum += __arr [ __k * __i + __j ] * __factor ;
__factor *= __detail :: _Shift < _UIntType , 32 > :: __value ;
}
_M_x [ __i ] = __detail :: __mod < _UIntType ,
__detail :: _Shift < _UIntType , __w > :: __value > ( __sum ) ;
}
_M_carry = ( _M_x [ long_lag - 1 ] == 0 ) ? 1 : 0 ;
_M_p = 0 ;
}

template < typename _UIntType , size_t __w , size_t __s , size_t __r >
typename subtract_with_carry_engine < _UIntType , __w , __s , __r > ::
result_type
subtract_with_carry_engine < _UIntType , __w , __s , __r > ::
operator ( ) ( )
{

long __ps = _M_p - short_lag ;
if ( __ps < 0 )
__ps += long_lag ;




_UIntType __xi ;
if ( _M_x [ __ps ] >= _M_x [ _M_p ] + _M_carry )
{
__xi = _M_x [ __ps ] - _M_x [ _M_p ] - _M_carry ;
_M_carry = 0 ;
}
else
{
__xi = ( __detail :: _Shift < _UIntType , __w > :: __value
- _M_x [ _M_p ] - _M_carry + _M_x [ __ps ] ) ;
_M_carry = 1 ;
}
_M_x [ _M_p ] = __xi ;


if ( ++ _M_p >= long_lag )
_M_p = 0 ;

return __xi ;
}

template < typename _UIntType , size_t __w , size_t __s , size_t __r ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const subtract_with_carry_engine < _UIntType ,
__w , __s , __r > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: dec | __ios_base :: fixed | __ios_base :: left ) ;
__os . fill ( __space ) ;

for ( size_t __i = 0 ; __i < __r ; ++ __i )
__os << __x . _M_x [ __i ] << __space ;
__os << __x . _M_carry << __space << __x . _M_p ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
return __os ;
}

template < typename _UIntType , size_t __w , size_t __s , size_t __r ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
subtract_with_carry_engine < _UIntType , __w , __s , __r > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

for ( size_t __i = 0 ; __i < __r ; ++ __i )
__is >> __x . _M_x [ __i ] ;
__is >> __x . _M_carry ;
__is >> __x . _M_p ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RandomNumberEngine , size_t __p , size_t __r >
constexpr size_t
discard_block_engine < _RandomNumberEngine , __p , __r > :: block_size ;

template < typename _RandomNumberEngine , size_t __p , size_t __r >
constexpr size_t
discard_block_engine < _RandomNumberEngine , __p , __r > :: used_block ;

template < typename _RandomNumberEngine , size_t __p , size_t __r >
typename discard_block_engine < _RandomNumberEngine ,
__p , __r > :: result_type
discard_block_engine < _RandomNumberEngine , __p , __r > ::
operator ( ) ( )
{
if ( _M_n >= used_block )
{
_M_b . discard ( block_size - _M_n ) ;
_M_n = 0 ;
}
++ _M_n ;
return _M_b ( ) ;
}

template < typename _RandomNumberEngine , size_t __p , size_t __r ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const discard_block_engine < _RandomNumberEngine ,
__p , __r > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: dec | __ios_base :: fixed | __ios_base :: left ) ;
__os . fill ( __space ) ;

__os << __x . base ( ) << __space << __x . _M_n ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
return __os ;
}

template < typename _RandomNumberEngine , size_t __p , size_t __r ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
discard_block_engine < _RandomNumberEngine , __p , __r > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

__is >> __x . _M_b >> __x . _M_n ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RandomNumberEngine , size_t __w , typename _UIntType >
typename independent_bits_engine < _RandomNumberEngine , __w , _UIntType > ::
result_type
independent_bits_engine < _RandomNumberEngine , __w , _UIntType > ::
operator ( ) ( )
{
typedef typename _RandomNumberEngine :: result_type _Eresult_type ;
const _Eresult_type __r
= ( _M_b . max ( ) - _M_b . min ( ) < std :: numeric_limits < _Eresult_type > :: max ( )
? _M_b . max ( ) - _M_b . min ( ) + 1 : 0 ) ;
const unsigned __edig = std :: numeric_limits < _Eresult_type > :: digits ;
const unsigned __m = __r ? std :: __lg ( __r ) : __edig ;

typedef typename std :: common_type < _Eresult_type , result_type > :: type
__ctype ;
const unsigned __cdig = std :: numeric_limits < __ctype > :: digits ;

unsigned __n , __n0 ;
__ctype __s0 , __s1 , __y0 , __y1 ;

for ( size_t __i = 0 ; __i < 2 ; ++ __i )
{
__n = ( __w + __m - 1 ) / __m + __i ;
__n0 = __n - __w % __n ;
const unsigned __w0 = __w / __n ;

__s0 = 0 ;
__s1 = 0 ;
if ( __w0 < __cdig )
{
__s0 = __ctype ( 1 ) << __w0 ;
__s1 = __s0 << 1 ;
}

__y0 = 0 ;
__y1 = 0 ;
if ( __r )
{
__y0 = __s0 * ( __r / __s0 ) ;
if ( __s1 )
__y1 = __s1 * ( __r / __s1 ) ;

if ( __r - __y0 <= __y0 / __n )
break ;
}
else
break ;
}

result_type __sum = 0 ;
for ( size_t __k = 0 ; __k < __n0 ; ++ __k )
{
__ctype __u ;
do
__u = _M_b ( ) - _M_b . min ( ) ;
while ( __y0 && __u >= __y0 ) ;
__sum = __s0 * __sum + ( __s0 ? __u % __s0 : __u ) ;
}
for ( size_t __k = __n0 ; __k < __n ; ++ __k )
{
__ctype __u ;
do
__u = _M_b ( ) - _M_b . min ( ) ;
while ( __y1 && __u >= __y1 ) ;
__sum = __s1 * __sum + ( __s1 ? __u % __s1 : __u ) ;
}
return __sum ;
}


template < typename _RandomNumberEngine , size_t __k >
constexpr size_t
shuffle_order_engine < _RandomNumberEngine , __k > :: table_size ;

template < typename _RandomNumberEngine , size_t __k >
typename shuffle_order_engine < _RandomNumberEngine , __k > :: result_type
shuffle_order_engine < _RandomNumberEngine , __k > ::
operator ( ) ( )
{
size_t __j = __k * ( ( _M_y - _M_b . min ( ) )
/ ( _M_b . max ( ) - _M_b . min ( ) + 1.0L ) ) ;
_M_y = _M_v [ __j ] ;
_M_v [ __j ] = _M_b ( ) ;

return _M_y ;
}

template < typename _RandomNumberEngine , size_t __k ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const shuffle_order_engine < _RandomNumberEngine , __k > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: dec | __ios_base :: fixed | __ios_base :: left ) ;
__os . fill ( __space ) ;

__os << __x . base ( ) ;
for ( size_t __i = 0 ; __i < __k ; ++ __i )
__os << __space << __x . _M_v [ __i ] ;
__os << __space << __x . _M_y ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
return __os ;
}

template < typename _RandomNumberEngine , size_t __k ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
shuffle_order_engine < _RandomNumberEngine , __k > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

__is >> __x . _M_b ;
for ( size_t __i = 0 ; __i < __k ; ++ __i )
__is >> __x . _M_v [ __i ] ;
__is >> __x . _M_y ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename uniform_int_distribution < _IntType > :: result_type
uniform_int_distribution < _IntType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
typedef typename _UniformRandomNumberGenerator :: result_type
_Gresult_type ;
typedef typename std :: make_unsigned < result_type > :: type __utype ;
typedef typename std :: common_type < _Gresult_type , __utype > :: type
__uctype ;

const __uctype __urngmin = __urng . min ( ) ;
const __uctype __urngmax = __urng . max ( ) ;
const __uctype __urngrange = __urngmax - __urngmin ;
const __uctype __urange
= __uctype ( __param . b ( ) ) - __uctype ( __param . a ( ) ) ;

__uctype __ret ;

if ( __urngrange > __urange )
{

const __uctype __uerange = __urange + 1 ;
const __uctype __scaling = __urngrange / __uerange ;
const __uctype __past = __uerange * __scaling ;
do
__ret = __uctype ( __urng ( ) ) - __urngmin ;
while ( __ret >= __past ) ;
__ret /= __scaling ;
}
else if ( __urngrange < __urange )
{
#924
__uctype __tmp ;
do
{
const __uctype __uerngrange = __urngrange + 1 ;
__tmp = ( __uerngrange * operator ( )
( __urng , param_type ( 0 , __urange / __uerngrange ) ) ) ;
__ret = __tmp + ( __uctype ( __urng ( ) ) - __urngmin ) ;
}
while ( __ret > __urange || __ret < __tmp ) ;
}
else
__ret = __uctype ( __urng ( ) ) - __urngmin ;

return __ret + __param . a ( ) ;
}


template < typename _IntType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
uniform_int_distribution < _IntType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{

typedef typename _UniformRandomNumberGenerator :: result_type
_Gresult_type ;
typedef typename std :: make_unsigned < result_type > :: type __utype ;
typedef typename std :: common_type < _Gresult_type , __utype > :: type
__uctype ;

const __uctype __urngmin = __urng . min ( ) ;
const __uctype __urngmax = __urng . max ( ) ;
const __uctype __urngrange = __urngmax - __urngmin ;
const __uctype __urange
= __uctype ( __param . b ( ) ) - __uctype ( __param . a ( ) ) ;

__uctype __ret ;

if ( __urngrange > __urange )
{
if ( __detail :: _Power_of_2 ( __urngrange + 1 )
&& __detail :: _Power_of_2 ( __urange + 1 ) )
{
while ( __f != __t )
{
__ret = __uctype ( __urng ( ) ) - __urngmin ;
* __f ++ = ( __ret & __urange ) + __param . a ( ) ;
}
}
else
{

const __uctype __uerange = __urange + 1 ;
const __uctype __scaling = __urngrange / __uerange ;
const __uctype __past = __uerange * __scaling ;
while ( __f != __t )
{
do
__ret = __uctype ( __urng ( ) ) - __urngmin ;
while ( __ret >= __past ) ;
* __f ++ = __ret / __scaling + __param . a ( ) ;
}
}
}
else if ( __urngrange < __urange )
{
#1008
__uctype __tmp ;
while ( __f != __t )
{
do
{
const __uctype __uerngrange = __urngrange + 1 ;
__tmp = ( __uerngrange * operator ( )
( __urng , param_type ( 0 , __urange / __uerngrange ) ) ) ;
__ret = __tmp + ( __uctype ( __urng ( ) ) - __urngmin ) ;
}
while ( __ret > __urange || __ret < __tmp ) ;
* __f ++ = __ret ;
}
}
else
while ( __f != __t )
* __f ++ = __uctype ( __urng ( ) ) - __urngmin + __param . a ( ) ;
}

template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const uniform_int_distribution < _IntType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;

__os << __x . a ( ) << __space << __x . b ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
return __os ;
}

template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
uniform_int_distribution < _IntType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_IntType __a , __b ;
__is >> __a >> __b ;
__x . param ( typename uniform_int_distribution < _IntType > ::
param_type ( __a , __b ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
uniform_real_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
auto __range = __p . b ( ) - __p . a ( ) ;
while ( __f != __t )
* __f ++ = __aurng ( ) * __range + __p . a ( ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const uniform_real_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . a ( ) << __space << __x . b ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
uniform_real_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: skipws ) ;

_RealType __a , __b ;
__is >> __a >> __b ;
__x . param ( typename uniform_real_distribution < _RealType > ::
param_type ( __a , __b ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: bernoulli_distribution ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;
auto __limit = __p . p ( ) * ( __aurng . max ( ) - __aurng . min ( ) ) ;

while ( __f != __t )
* __f ++ = ( __aurng ( ) - __aurng . min ( ) ) < __limit ;
}

template < typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const bernoulli_distribution & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __os . widen ( ' ' ) ) ;
__os . precision ( std :: numeric_limits < double > :: max_digits10 ) ;

__os << __x . p ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}


template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename geometric_distribution < _IntType > :: result_type
geometric_distribution < _IntType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{


const double __naf =
( 1 - std :: numeric_limits < double > :: epsilon ( ) ) / 2 ;

const double __thr =
std :: numeric_limits < _IntType > :: max ( ) + __naf ;
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

double __cand ;
do
__cand = std :: floor ( std :: log ( 1.0 - __aurng ( ) ) / __param . _M_log_1_p ) ;
while ( __cand >= __thr ) ;

return result_type ( __cand + __naf ) ;
}

template < typename _IntType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
geometric_distribution < _IntType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{



const double __naf =
( 1 - std :: numeric_limits < double > :: epsilon ( ) ) / 2 ;

const double __thr =
std :: numeric_limits < _IntType > :: max ( ) + __naf ;
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

while ( __f != __t )
{
double __cand ;
do
__cand = std :: floor ( std :: log ( 1.0 - __aurng ( ) )
/ __param . _M_log_1_p ) ;
while ( __cand >= __thr ) ;

* __f ++ = __cand + __naf ;
}
}

template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const geometric_distribution < _IntType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __os . widen ( ' ' ) ) ;
__os . precision ( std :: numeric_limits < double > :: max_digits10 ) ;

__os << __x . p ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
geometric_distribution < _IntType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: skipws ) ;

double __p ;
__is >> __p ;
__x . param ( typename geometric_distribution < _IntType > :: param_type ( __p ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename negative_binomial_distribution < _IntType > :: result_type
negative_binomial_distribution < _IntType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng )
{
const double __y = _M_gd ( __urng ) ;


std :: poisson_distribution < result_type > __poisson ( __y ) ;
return __poisson ( __urng ) ;
}

template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename negative_binomial_distribution < _IntType > :: result_type
negative_binomial_distribution < _IntType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
typedef typename std :: gamma_distribution < double > :: param_type
param_type ;

const double __y =
_M_gd ( __urng , param_type ( __p . k ( ) , ( 1.0 - __p . p ( ) ) / __p . p ( ) ) ) ;

std :: poisson_distribution < result_type > __poisson ( __y ) ;
return __poisson ( __urng ) ;
}

template < typename _IntType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
negative_binomial_distribution < _IntType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{

while ( __f != __t )
{
const double __y = _M_gd ( __urng ) ;


std :: poisson_distribution < result_type > __poisson ( __y ) ;
* __f ++ = __poisson ( __urng ) ;
}
}

template < typename _IntType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
negative_binomial_distribution < _IntType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

typename std :: gamma_distribution < result_type > :: param_type
__p2 ( __p . k ( ) , ( 1.0 - __p . p ( ) ) / __p . p ( ) ) ;

while ( __f != __t )
{
const double __y = _M_gd ( __urng , __p2 ) ;

std :: poisson_distribution < result_type > __poisson ( __y ) ;
* __f ++ = __poisson ( __urng ) ;
}
}

template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const negative_binomial_distribution < _IntType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __os . widen ( ' ' ) ) ;
__os . precision ( std :: numeric_limits < double > :: max_digits10 ) ;

__os << __x . k ( ) << __space << __x . p ( )
<< __space << __x . _M_gd ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
negative_binomial_distribution < _IntType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: skipws ) ;

_IntType __k ;
double __p ;
__is >> __k >> __p >> __x . _M_gd ;
__x . param ( typename negative_binomial_distribution < _IntType > ::
param_type ( __k , __p ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _IntType >
void
poisson_distribution < _IntType > :: param_type ::
_M_initialize ( )
{

if ( _M_mean >= 12 )
{
const double __m = std :: floor ( _M_mean ) ;
_M_lm_thr = std :: log ( _M_mean ) ;
_M_lfm = std :: lgamma ( __m + 1 ) ;
_M_sm = std :: sqrt ( __m ) ;

const double __pi_4 = 0.7853981633974483096156608458198757L ;
const double __dx = std :: sqrt ( 2 * __m * std :: log ( 32 * __m
/ __pi_4 ) ) ;
_M_d = std :: round ( std :: max ( 6.0 , std :: min ( __m , __dx ) ) ) ;
const double __cx = 2 * __m + _M_d ;
_M_scx = std :: sqrt ( __cx / 2 ) ;
_M_1cx = 1 / __cx ;

_M_c2b = std :: sqrt ( __pi_4 * __cx ) * std :: exp ( _M_1cx ) ;
_M_cb = 2 * __cx * std :: exp ( - _M_d * _M_1cx * ( 1 + _M_d / 2 ) )
/ _M_d ;
}
else

_M_lm_thr = std :: exp ( - _M_mean ) ;
}
#1432
template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename poisson_distribution < _IntType > :: result_type
poisson_distribution < _IntType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

if ( __param . mean ( ) >= 12 )
{
double __x ;


const double __naf =
( 1 - std :: numeric_limits < double > :: epsilon ( ) ) / 2 ;
const double __thr =
std :: numeric_limits < _IntType > :: max ( ) + __naf ;

const double __m = std :: floor ( __param . mean ( ) ) ;

const double __spi_2 = 1.2533141373155002512078826424055226L ;
const double __c1 = __param . _M_sm * __spi_2 ;
const double __c2 = __param . _M_c2b + __c1 ;
const double __c3 = __c2 + 1 ;
const double __c4 = __c3 + 1 ;

const double __e178 = 1.0129030479320018583185514777512983L ;
const double __c5 = __c4 + __e178 ;
const double __c = __param . _M_cb + __c5 ;
const double __2cx = 2 * ( 2 * __m + __param . _M_d ) ;

bool __reject = true ;
do
{
const double __u = __c * __aurng ( ) ;
const double __e = - std :: log ( 1.0 - __aurng ( ) ) ;

double __w = 0.0 ;

if ( __u <= __c1 )
{
const double __n = _M_nd ( __urng ) ;
const double __y = - std :: abs ( __n ) * __param . _M_sm - 1 ;
__x = std :: floor ( __y ) ;
__w = - __n * __n / 2 ;
if ( __x < - __m )
continue ;
}
else if ( __u <= __c2 )
{
const double __n = _M_nd ( __urng ) ;
const double __y = 1 + std :: abs ( __n ) * __param . _M_scx ;
__x = std :: ceil ( __y ) ;
__w = __y * ( 2 - __y ) * __param . _M_1cx ;
if ( __x > __param . _M_d )
continue ;
}
else if ( __u <= __c3 )


__x = - 1 ;
else if ( __u <= __c4 )
__x = 0 ;
else if ( __u <= __c5 )
__x = 1 ;
else
{
const double __v = - std :: log ( 1.0 - __aurng ( ) ) ;
const double __y = __param . _M_d
+ __v * __2cx / __param . _M_d ;
__x = std :: ceil ( __y ) ;
__w = - __param . _M_d * __param . _M_1cx * ( 1 + __y / 2 ) ;
}

__reject = ( __w - __e - __x * __param . _M_lm_thr
> __param . _M_lfm - std :: lgamma ( __x + __m + 1 ) ) ;

__reject |= __x + __m >= __thr ;

} while ( __reject ) ;

return result_type ( __x + __m + __naf ) ;
}
else

{
_IntType __x = 0 ;
double __prod = 1.0 ;

do
{
__prod *= __aurng ( ) ;
__x += 1 ;
}
while ( __prod > __param . _M_lm_thr ) ;

return __x - 1 ;
}
}

template < typename _IntType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
poisson_distribution < _IntType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{


while ( __f != __t )
* __f ++ = this -> operator ( ) ( __urng , __param ) ;
}

template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const poisson_distribution < _IntType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < double > :: max_digits10 ) ;

__os << __x . mean ( ) << __space << __x . _M_nd ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
poisson_distribution < _IntType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: skipws ) ;

double __mean ;
__is >> __mean >> __x . _M_nd ;
__x . param ( typename poisson_distribution < _IntType > :: param_type ( __mean ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _IntType >
void
binomial_distribution < _IntType > :: param_type ::
_M_initialize ( )
{
const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p ;

_M_easy = true ;


if ( _M_t * __p12 >= 8 )
{
_M_easy = false ;
const double __np = std :: floor ( _M_t * __p12 ) ;
const double __pa = __np / _M_t ;
const double __1p = 1 - __pa ;

const double __pi_4 = 0.7853981633974483096156608458198757L ;
const double __d1x =
std :: sqrt ( __np * __1p * std :: log ( 32 * __np
/ ( 81 * __pi_4 * __1p ) ) ) ;
_M_d1 = std :: round ( std :: max ( 1.0 , __d1x ) ) ;
const double __d2x =
std :: sqrt ( __np * __1p * std :: log ( 32 * _M_t * __1p
/ ( __pi_4 * __pa ) ) ) ;
_M_d2 = std :: round ( std :: max ( 1.0 , __d2x ) ) ;


const double __spi_2 = 1.2533141373155002512078826424055226L ;
_M_s1 = std :: sqrt ( __np * __1p ) * ( 1 + _M_d1 / ( 4 * __np ) ) ;
_M_s2 = std :: sqrt ( __np * __1p ) * ( 1 + _M_d2 / ( 4 * _M_t * __1p ) ) ;
_M_c = 2 * _M_d1 / __np ;
_M_a1 = std :: exp ( _M_c ) * _M_s1 * __spi_2 ;
const double __a12 = _M_a1 + _M_s2 * __spi_2 ;
const double __s1s = _M_s1 * _M_s1 ;
_M_a123 = __a12 + ( std :: exp ( _M_d1 / ( _M_t * __1p ) )
* 2 * __s1s / _M_d1
* std :: exp ( - _M_d1 * _M_d1 / ( 2 * __s1s ) ) ) ;
const double __s2s = _M_s2 * _M_s2 ;
_M_s = ( _M_a123 + 2 * __s2s / _M_d2
* std :: exp ( - _M_d2 * _M_d2 / ( 2 * __s2s ) ) ) ;
_M_lf = ( std :: lgamma ( __np + 1 )
+ std :: lgamma ( _M_t - __np + 1 ) ) ;
_M_lp1p = std :: log ( __pa / __1p ) ;

_M_q = - std :: log ( 1 - ( __p12 - __pa ) / __1p ) ;
}
else

_M_q = - std :: log ( 1 - __p12 ) ;
}

template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename binomial_distribution < _IntType > :: result_type
binomial_distribution < _IntType > ::
_M_waiting ( _UniformRandomNumberGenerator & __urng ,
_IntType __t , double __q )
{
_IntType __x = 0 ;
double __sum = 0.0 ;
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

do
{
if ( __t == __x )
return __x ;
const double __e = - std :: log ( 1.0 - __aurng ( ) ) ;
__sum += __e / ( __t - __x ) ;
__x += 1 ;
}
while ( __sum <= __q ) ;

return __x - 1 ;
}
#1682
template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename binomial_distribution < _IntType > :: result_type
binomial_distribution < _IntType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
result_type __ret ;
const _IntType __t = __param . t ( ) ;
const double __p = __param . p ( ) ;
const double __p12 = __p <= 0.5 ? __p : 1.0 - __p ;
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;


if ( ! __param . _M_easy )
{
double __x ;


const double __naf =
( 1 - std :: numeric_limits < double > :: epsilon ( ) ) / 2 ;
const double __thr =
std :: numeric_limits < _IntType > :: max ( ) + __naf ;

const double __np = std :: floor ( __t * __p12 ) ;


const double __spi_2 = 1.2533141373155002512078826424055226L ;
const double __a1 = __param . _M_a1 ;
const double __a12 = __a1 + __param . _M_s2 * __spi_2 ;
const double __a123 = __param . _M_a123 ;
const double __s1s = __param . _M_s1 * __param . _M_s1 ;
const double __s2s = __param . _M_s2 * __param . _M_s2 ;

bool __reject ;
do
{
const double __u = __param . _M_s * __aurng ( ) ;

double __v ;

if ( __u <= __a1 )
{
const double __n = _M_nd ( __urng ) ;
const double __y = __param . _M_s1 * std :: abs ( __n ) ;
__reject = __y >= __param . _M_d1 ;
if ( ! __reject )
{
const double __e = - std :: log ( 1.0 - __aurng ( ) ) ;
__x = std :: floor ( __y ) ;
__v = - __e - __n * __n / 2 + __param . _M_c ;
}
}
else if ( __u <= __a12 )
{
const double __n = _M_nd ( __urng ) ;
const double __y = __param . _M_s2 * std :: abs ( __n ) ;
__reject = __y >= __param . _M_d2 ;
if ( ! __reject )
{
const double __e = - std :: log ( 1.0 - __aurng ( ) ) ;
__x = std :: floor ( - __y ) ;
__v = - __e - __n * __n / 2 ;
}
}
else if ( __u <= __a123 )
{
const double __e1 = - std :: log ( 1.0 - __aurng ( ) ) ;
const double __e2 = - std :: log ( 1.0 - __aurng ( ) ) ;

const double __y = __param . _M_d1
+ 2 * __s1s * __e1 / __param . _M_d1 ;
__x = std :: floor ( __y ) ;
__v = ( - __e2 + __param . _M_d1 * ( 1 / ( __t - __np )
- __y / ( 2 * __s1s ) ) ) ;
__reject = false ;
}
else
{
const double __e1 = - std :: log ( 1.0 - __aurng ( ) ) ;
const double __e2 = - std :: log ( 1.0 - __aurng ( ) ) ;

const double __y = __param . _M_d2
+ 2 * __s2s * __e1 / __param . _M_d2 ;
__x = std :: floor ( - __y ) ;
__v = - __e2 - __param . _M_d2 * __y / ( 2 * __s2s ) ;
__reject = false ;
}

__reject = __reject || __x < - __np || __x > __t - __np ;
if ( ! __reject )
{
const double __lfx =
std :: lgamma ( __np + __x + 1 )
+ std :: lgamma ( __t - ( __np + __x ) + 1 ) ;
__reject = __v > __param . _M_lf - __lfx
+ __x * __param . _M_lp1p ;
}

__reject |= __x + __np >= __thr ;
}
while ( __reject ) ;

__x += __np + __naf ;

const _IntType __z = _M_waiting ( __urng , __t - _IntType ( __x ) ,
__param . _M_q ) ;
__ret = _IntType ( __x ) + __z ;
}
else

__ret = _M_waiting ( __urng , __t , __param . _M_q ) ;

if ( __p12 != __p )
__ret = __t - __ret ;
return __ret ;
}

template < typename _IntType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
binomial_distribution < _IntType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{


while ( __f != __t )
* __f ++ = this -> operator ( ) ( __urng , __param ) ;
}

template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const binomial_distribution < _IntType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < double > :: max_digits10 ) ;

__os << __x . t ( ) << __space << __x . p ( )
<< __space << __x . _M_nd ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _IntType ,
typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
binomial_distribution < _IntType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_IntType __t ;
double __p ;
__is >> __t >> __p >> __x . _M_nd ;
__x . param ( typename binomial_distribution < _IntType > ::
param_type ( __t , __p ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: exponential_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
while ( __f != __t )
* __f ++ = - std :: log ( result_type ( 1 ) - __aurng ( ) ) / __p . lambda ( ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const exponential_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __os . widen ( ' ' ) ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . lambda ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
exponential_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __lambda ;
__is >> __lambda ;
__x . param ( typename exponential_distribution < _RealType > ::
param_type ( __lambda ) ) ;

__is . flags ( __flags ) ;
return __is ;
}
#1931
template < typename _RealType >
template < typename _UniformRandomNumberGenerator >
typename normal_distribution < _RealType > :: result_type
normal_distribution < _RealType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
result_type __ret ;
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;

if ( _M_saved_available )
{
_M_saved_available = false ;
__ret = _M_saved ;
}
else
{
result_type __x , __y , __r2 ;
do
{
__x = result_type ( 2.0 ) * __aurng ( ) - 1.0 ;
__y = result_type ( 2.0 ) * __aurng ( ) - 1.0 ;
__r2 = __x * __x + __y * __y ;
}
while ( __r2 > 1.0 || __r2 == 0.0 ) ;

const result_type __mult = std :: sqrt ( - 2 * std :: log ( __r2 ) / __r2 ) ;
_M_saved = __x * __mult ;
_M_saved_available = true ;
__ret = __y * __mult ;
}

__ret = __ret * __param . stddev ( ) + __param . mean ( ) ;
return __ret ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
normal_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{


if ( __f == __t )
return ;

if ( _M_saved_available )
{
_M_saved_available = false ;
* __f ++ = _M_saved * __param . stddev ( ) + __param . mean ( ) ;

if ( __f == __t )
return ;
}

__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;

while ( __f + 1 < __t )
{
result_type __x , __y , __r2 ;
do
{
__x = result_type ( 2.0 ) * __aurng ( ) - 1.0 ;
__y = result_type ( 2.0 ) * __aurng ( ) - 1.0 ;
__r2 = __x * __x + __y * __y ;
}
while ( __r2 > 1.0 || __r2 == 0.0 ) ;

const result_type __mult = std :: sqrt ( - 2 * std :: log ( __r2 ) / __r2 ) ;
* __f ++ = __y * __mult * __param . stddev ( ) + __param . mean ( ) ;
* __f ++ = __x * __mult * __param . stddev ( ) + __param . mean ( ) ;
}

if ( __f != __t )
{
result_type __x , __y , __r2 ;
do
{
__x = result_type ( 2.0 ) * __aurng ( ) - 1.0 ;
__y = result_type ( 2.0 ) * __aurng ( ) - 1.0 ;
__r2 = __x * __x + __y * __y ;
}
while ( __r2 > 1.0 || __r2 == 0.0 ) ;

const result_type __mult = std :: sqrt ( - 2 * std :: log ( __r2 ) / __r2 ) ;
_M_saved = __x * __mult ;
_M_saved_available = true ;
* __f = __y * __mult * __param . stddev ( ) + __param . mean ( ) ;
}
}

template < typename _RealType >
bool
operator == ( const std :: normal_distribution < _RealType > & __d1 ,
const std :: normal_distribution < _RealType > & __d2 )
{
if ( __d1 . _M_param == __d2 . _M_param
&& __d1 . _M_saved_available == __d2 . _M_saved_available )
{
if ( __d1 . _M_saved_available
&& __d1 . _M_saved == __d2 . _M_saved )
return true ;
else if ( ! __d1 . _M_saved_available )
return true ;
else
return false ;
}
else
return false ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const normal_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . mean ( ) << __space << __x . stddev ( )
<< __space << __x . _M_saved_available ;
if ( __x . _M_saved_available )
__os << __space << __x . _M_saved ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
normal_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

double __mean , __stddev ;
__is >> __mean >> __stddev
>> __x . _M_saved_available ;
if ( __x . _M_saved_available )
__is >> __x . _M_saved ;
__x . param ( typename normal_distribution < _RealType > ::
param_type ( __mean , __stddev ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
lognormal_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

while ( __f != __t )
* __f ++ = std :: exp ( __p . s ( ) * _M_nd ( __urng ) + __p . m ( ) ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const lognormal_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . m ( ) << __space << __x . s ( )
<< __space << __x . _M_nd ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
lognormal_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __m , __s ;
__is >> __m >> __s >> __x . _M_nd ;
__x . param ( typename lognormal_distribution < _RealType > ::
param_type ( __m , __s ) ) ;

__is . flags ( __flags ) ;
return __is ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: chi_squared_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{

while ( __f != __t )
* __f ++ = 2 * _M_gd ( __urng ) ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: chi_squared_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const typename
std :: gamma_distribution < result_type > :: param_type & __p )
{

while ( __f != __t )
* __f ++ = 2 * _M_gd ( __urng , __p ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const chi_squared_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . n ( ) << __space << __x . _M_gd ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
chi_squared_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __n ;
__is >> __n >> __x . _M_gd ;
__x . param ( typename chi_squared_distribution < _RealType > ::
param_type ( __n ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _UniformRandomNumberGenerator >
typename cauchy_distribution < _RealType > :: result_type
cauchy_distribution < _RealType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
_RealType __u ;
do
__u = __aurng ( ) ;
while ( __u == 0.5 ) ;

const _RealType __pi = 3.1415926535897932384626433832795029L ;
return __p . a ( ) + __p . b ( ) * std :: tan ( __pi * __u ) ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
cauchy_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

const _RealType __pi = 3.1415926535897932384626433832795029L ;
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
while ( __f != __t )
{
_RealType __u ;
do
__u = __aurng ( ) ;
while ( __u == 0.5 ) ;

* __f ++ = __p . a ( ) + __p . b ( ) * std :: tan ( __pi * __u ) ;
}
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const cauchy_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . a ( ) << __space << __x . b ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
cauchy_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __a , __b ;
__is >> __a >> __b ;
__x . param ( typename cauchy_distribution < _RealType > ::
param_type ( __a , __b ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: fisher_f_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{

while ( __f != __t )
* __f ++ = ( ( _M_gd_x ( __urng ) * n ( ) ) / ( _M_gd_y ( __urng ) * m ( ) ) ) ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: fisher_f_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

typedef typename std :: gamma_distribution < result_type > :: param_type
param_type ;
param_type __p1 ( __p . m ( ) / 2 ) ;
param_type __p2 ( __p . n ( ) / 2 ) ;
while ( __f != __t )
* __f ++ = ( ( _M_gd_x ( __urng , __p1 ) * n ( ) )
/ ( _M_gd_y ( __urng , __p2 ) * m ( ) ) ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const fisher_f_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . m ( ) << __space << __x . n ( )
<< __space << __x . _M_gd_x << __space << __x . _M_gd_y ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
fisher_f_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __m , __n ;
__is >> __m >> __n >> __x . _M_gd_x >> __x . _M_gd_y ;
__x . param ( typename fisher_f_distribution < _RealType > ::
param_type ( __m , __n ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: student_t_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng )
{

while ( __f != __t )
* __f ++ = _M_nd ( __urng ) * std :: sqrt ( n ( ) / _M_gd ( __urng ) ) ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
std :: student_t_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

typename std :: gamma_distribution < result_type > :: param_type
__p2 ( __p . n ( ) / 2 , 2 ) ;
while ( __f != __t )
* __f ++ = _M_nd ( __urng ) * std :: sqrt ( __p . n ( ) / _M_gd ( __urng , __p2 ) ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const student_t_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . n ( ) << __space << __x . _M_nd << __space << __x . _M_gd ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
student_t_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __n ;
__is >> __n >> __x . _M_nd >> __x . _M_gd ;
__x . param ( typename student_t_distribution < _RealType > :: param_type ( __n ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
void
gamma_distribution < _RealType > :: param_type ::
_M_initialize ( )
{
_M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType ( 1.0 ) : _M_alpha ;

const _RealType __a1 = _M_malpha - _RealType ( 1.0 ) / _RealType ( 3.0 ) ;
_M_a2 = _RealType ( 1.0 ) / std :: sqrt ( _RealType ( 9.0 ) * __a1 ) ;
}
#2485
template < typename _RealType >
template < typename _UniformRandomNumberGenerator >
typename gamma_distribution < _RealType > :: result_type
gamma_distribution < _RealType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;

result_type __u , __v , __n ;
const result_type __a1 = ( __param . _M_malpha
- _RealType ( 1.0 ) / _RealType ( 3.0 ) ) ;

do
{
do
{
__n = _M_nd ( __urng ) ;
__v = result_type ( 1.0 ) + __param . _M_a2 * __n ;
}
while ( __v <= 0.0 ) ;

__v = __v * __v * __v ;
__u = __aurng ( ) ;
}
while ( __u > result_type ( 1.0 ) - 0.331 * __n * __n * __n * __n
&& ( std :: log ( __u ) > ( 0.5 * __n * __n + __a1
* ( 1.0 - __v + std :: log ( __v ) ) ) ) ) ;

if ( __param . alpha ( ) == __param . _M_malpha )
return __a1 * __v * __param . beta ( ) ;
else
{
do
__u = __aurng ( ) ;
while ( __u == 0.0 ) ;

return ( std :: pow ( __u , result_type ( 1.0 ) / __param . alpha ( ) )
* __a1 * __v * __param . beta ( ) ) ;
}
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
gamma_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{

__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;

result_type __u , __v , __n ;
const result_type __a1 = ( __param . _M_malpha
- _RealType ( 1.0 ) / _RealType ( 3.0 ) ) ;

if ( __param . alpha ( ) == __param . _M_malpha )
while ( __f != __t )
{
do
{
do
{
__n = _M_nd ( __urng ) ;
__v = result_type ( 1.0 ) + __param . _M_a2 * __n ;
}
while ( __v <= 0.0 ) ;

__v = __v * __v * __v ;
__u = __aurng ( ) ;
}
while ( __u > result_type ( 1.0 ) - 0.331 * __n * __n * __n * __n
&& ( std :: log ( __u ) > ( 0.5 * __n * __n + __a1
* ( 1.0 - __v + std :: log ( __v ) ) ) ) ) ;

* __f ++ = __a1 * __v * __param . beta ( ) ;
}
else
while ( __f != __t )
{
do
{
do
{
__n = _M_nd ( __urng ) ;
__v = result_type ( 1.0 ) + __param . _M_a2 * __n ;
}
while ( __v <= 0.0 ) ;

__v = __v * __v * __v ;
__u = __aurng ( ) ;
}
while ( __u > result_type ( 1.0 ) - 0.331 * __n * __n * __n * __n
&& ( std :: log ( __u ) > ( 0.5 * __n * __n + __a1
* ( 1.0 - __v + std :: log ( __v ) ) ) ) ) ;

do
__u = __aurng ( ) ;
while ( __u == 0.0 ) ;

* __f ++ = ( std :: pow ( __u , result_type ( 1.0 ) / __param . alpha ( ) )
* __a1 * __v * __param . beta ( ) ) ;
}
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const gamma_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . alpha ( ) << __space << __x . beta ( )
<< __space << __x . _M_nd ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
gamma_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __alpha_val , __beta_val ;
__is >> __alpha_val >> __beta_val >> __x . _M_nd ;
__x . param ( typename gamma_distribution < _RealType > ::
param_type ( __alpha_val , __beta_val ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _UniformRandomNumberGenerator >
typename weibull_distribution < _RealType > :: result_type
weibull_distribution < _RealType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
return __p . b ( ) * std :: pow ( - std :: log ( result_type ( 1 ) - __aurng ( ) ) ,
result_type ( 1 ) / __p . a ( ) ) ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
weibull_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
auto __inv_a = result_type ( 1 ) / __p . a ( ) ;

while ( __f != __t )
* __f ++ = __p . b ( ) * std :: pow ( - std :: log ( result_type ( 1 ) - __aurng ( ) ) ,
__inv_a ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const weibull_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . a ( ) << __space << __x . b ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
weibull_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __a , __b ;
__is >> __a >> __b ;
__x . param ( typename weibull_distribution < _RealType > ::
param_type ( __a , __b ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
template < typename _UniformRandomNumberGenerator >
typename extreme_value_distribution < _RealType > :: result_type
extreme_value_distribution < _RealType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;
return __p . a ( ) - __p . b ( ) * std :: log ( - std :: log ( result_type ( 1 )
- __aurng ( ) ) ) ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
extreme_value_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __p )
{

__detail :: _Adaptor < _UniformRandomNumberGenerator , result_type >
__aurng ( __urng ) ;

while ( __f != __t )
* __f ++ = __p . a ( ) - __p . b ( ) * std :: log ( - std :: log ( result_type ( 1 )
- __aurng ( ) ) ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const extreme_value_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

__os << __x . a ( ) << __space << __x . b ( ) ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
extreme_value_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

_RealType __a , __b ;
__is >> __a >> __b ;
__x . param ( typename extreme_value_distribution < _RealType > ::
param_type ( __a , __b ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _IntType >
void
discrete_distribution < _IntType > :: param_type ::
_M_initialize ( )
{
if ( _M_prob . size ( ) < 2 )
{
_M_prob . clear ( ) ;
return ;
}

const double __sum = std :: accumulate ( _M_prob . begin ( ) ,
_M_prob . end ( ) , 0.0 ) ;

__detail :: __normalize ( _M_prob . begin ( ) , _M_prob . end ( ) , _M_prob . begin ( ) ,
__sum ) ;

_M_cp . reserve ( _M_prob . size ( ) ) ;
std :: partial_sum ( _M_prob . begin ( ) , _M_prob . end ( ) ,
std :: back_inserter ( _M_cp ) ) ;

_M_cp [ _M_cp . size ( ) - 1 ] = 1.0 ;
}

template < typename _IntType >
template < typename _Func >
discrete_distribution < _IntType > :: param_type ::
param_type ( size_t __nw , double __xmin , double __xmax , _Func __fw )
: _M_prob ( ) , _M_cp ( )
{
const size_t __n = __nw == 0 ? 1 : __nw ;
const double __delta = ( __xmax - __xmin ) / __n ;

_M_prob . reserve ( __n ) ;
for ( size_t __k = 0 ; __k < __nw ; ++ __k )
_M_prob . push_back ( __fw ( __xmin + __k * __delta + 0.5 * __delta ) ) ;

_M_initialize ( ) ;
}

template < typename _IntType >
template < typename _UniformRandomNumberGenerator >
typename discrete_distribution < _IntType > :: result_type
discrete_distribution < _IntType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
if ( __param . _M_cp . empty ( ) )
return result_type ( 0 ) ;

__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

const double __p = __aurng ( ) ;
auto __pos = std :: lower_bound ( __param . _M_cp . begin ( ) ,
__param . _M_cp . end ( ) , __p ) ;

return __pos - __param . _M_cp . begin ( ) ;
}

template < typename _IntType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
discrete_distribution < _IntType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{


if ( __param . _M_cp . empty ( ) )
{
while ( __f != __t )
* __f ++ = result_type ( 0 ) ;
return ;
}

__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

while ( __f != __t )
{
const double __p = __aurng ( ) ;
auto __pos = std :: lower_bound ( __param . _M_cp . begin ( ) ,
__param . _M_cp . end ( ) , __p ) ;

* __f ++ = __pos - __param . _M_cp . begin ( ) ;
}
}

template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const discrete_distribution < _IntType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < double > :: max_digits10 ) ;

std :: vector < double > __prob = __x . probabilities ( ) ;
__os << __prob . size ( ) ;
for ( auto __dit = __prob . begin ( ) ; __dit != __prob . end ( ) ; ++ __dit )
__os << __space << * __dit ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _IntType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
discrete_distribution < _IntType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

size_t __n ;
__is >> __n ;

std :: vector < double > __prob_vec ;
__prob_vec . reserve ( __n ) ;
for ( ; __n != 0 ; -- __n )
{
double __prob ;
__is >> __prob ;
__prob_vec . push_back ( __prob ) ;
}

__x . param ( typename discrete_distribution < _IntType > ::
param_type ( __prob_vec . begin ( ) , __prob_vec . end ( ) ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
void
piecewise_constant_distribution < _RealType > :: param_type ::
_M_initialize ( )
{
if ( _M_int . size ( ) < 2
|| ( _M_int . size ( ) == 2
&& _M_int [ 0 ] == _RealType ( 0 )
&& _M_int [ 1 ] == _RealType ( 1 ) ) )
{
_M_int . clear ( ) ;
_M_den . clear ( ) ;
return ;
}

const double __sum = std :: accumulate ( _M_den . begin ( ) ,
_M_den . end ( ) , 0.0 ) ;

__detail :: __normalize ( _M_den . begin ( ) , _M_den . end ( ) , _M_den . begin ( ) ,
__sum ) ;

_M_cp . reserve ( _M_den . size ( ) ) ;
std :: partial_sum ( _M_den . begin ( ) , _M_den . end ( ) ,
std :: back_inserter ( _M_cp ) ) ;


_M_cp [ _M_cp . size ( ) - 1 ] = 1.0 ;

for ( size_t __k = 0 ; __k < _M_den . size ( ) ; ++ __k )
_M_den [ __k ] /= _M_int [ __k + 1 ] - _M_int [ __k ] ;
}

template < typename _RealType >
template < typename _InputIteratorB , typename _InputIteratorW >
piecewise_constant_distribution < _RealType > :: param_type ::
param_type ( _InputIteratorB __bbegin ,
_InputIteratorB __bend ,
_InputIteratorW __wbegin )
: _M_int ( ) , _M_den ( ) , _M_cp ( )
{
if ( __bbegin != __bend )
{
for ( ; ; )
{
_M_int . push_back ( * __bbegin ) ;
++ __bbegin ;
if ( __bbegin == __bend )
break ;

_M_den . push_back ( * __wbegin ) ;
++ __wbegin ;
}
}

_M_initialize ( ) ;
}

template < typename _RealType >
template < typename _Func >
piecewise_constant_distribution < _RealType > :: param_type ::
param_type ( initializer_list < _RealType > __bl , _Func __fw )
: _M_int ( ) , _M_den ( ) , _M_cp ( )
{
_M_int . reserve ( __bl . size ( ) ) ;
for ( auto __biter = __bl . begin ( ) ; __biter != __bl . end ( ) ; ++ __biter )
_M_int . push_back ( * __biter ) ;

_M_den . reserve ( _M_int . size ( ) - 1 ) ;
for ( size_t __k = 0 ; __k < _M_int . size ( ) - 1 ; ++ __k )
_M_den . push_back ( __fw ( 0.5 * ( _M_int [ __k + 1 ] + _M_int [ __k ] ) ) ) ;

_M_initialize ( ) ;
}

template < typename _RealType >
template < typename _Func >
piecewise_constant_distribution < _RealType > :: param_type ::
param_type ( size_t __nw , _RealType __xmin , _RealType __xmax , _Func __fw )
: _M_int ( ) , _M_den ( ) , _M_cp ( )
{
const size_t __n = __nw == 0 ? 1 : __nw ;
const _RealType __delta = ( __xmax - __xmin ) / __n ;

_M_int . reserve ( __n + 1 ) ;
for ( size_t __k = 0 ; __k <= __nw ; ++ __k )
_M_int . push_back ( __xmin + __k * __delta ) ;

_M_den . reserve ( __n ) ;
for ( size_t __k = 0 ; __k < __nw ; ++ __k )
_M_den . push_back ( __fw ( _M_int [ __k ] + 0.5 * __delta ) ) ;

_M_initialize ( ) ;
}

template < typename _RealType >
template < typename _UniformRandomNumberGenerator >
typename piecewise_constant_distribution < _RealType > :: result_type
piecewise_constant_distribution < _RealType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

const double __p = __aurng ( ) ;
if ( __param . _M_cp . empty ( ) )
return __p ;

auto __pos = std :: lower_bound ( __param . _M_cp . begin ( ) ,
__param . _M_cp . end ( ) , __p ) ;
const size_t __i = __pos - __param . _M_cp . begin ( ) ;

const double __pref = __i > 0 ? __param . _M_cp [ __i - 1 ] : 0.0 ;

return __param . _M_int [ __i ] + ( __p - __pref ) / __param . _M_den [ __i ] ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
piecewise_constant_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{

__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

if ( __param . _M_cp . empty ( ) )
{
while ( __f != __t )
* __f ++ = __aurng ( ) ;
return ;
}

while ( __f != __t )
{
const double __p = __aurng ( ) ;

auto __pos = std :: lower_bound ( __param . _M_cp . begin ( ) ,
__param . _M_cp . end ( ) , __p ) ;
const size_t __i = __pos - __param . _M_cp . begin ( ) ;

const double __pref = __i > 0 ? __param . _M_cp [ __i - 1 ] : 0.0 ;

* __f ++ = ( __param . _M_int [ __i ]
+ ( __p - __pref ) / __param . _M_den [ __i ] ) ;
}
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const piecewise_constant_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

std :: vector < _RealType > __int = __x . intervals ( ) ;
__os << __int . size ( ) - 1 ;

for ( auto __xit = __int . begin ( ) ; __xit != __int . end ( ) ; ++ __xit )
__os << __space << * __xit ;

std :: vector < double > __den = __x . densities ( ) ;
for ( auto __dit = __den . begin ( ) ; __dit != __den . end ( ) ; ++ __dit )
__os << __space << * __dit ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
piecewise_constant_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

size_t __n ;
__is >> __n ;

std :: vector < _RealType > __int_vec ;
__int_vec . reserve ( __n + 1 ) ;
for ( size_t __i = 0 ; __i <= __n ; ++ __i )
{
_RealType __int ;
__is >> __int ;
__int_vec . push_back ( __int ) ;
}

std :: vector < double > __den_vec ;
__den_vec . reserve ( __n ) ;
for ( size_t __i = 0 ; __i < __n ; ++ __i )
{
double __den ;
__is >> __den ;
__den_vec . push_back ( __den ) ;
}

__x . param ( typename piecewise_constant_distribution < _RealType > ::
param_type ( __int_vec . begin ( ) , __int_vec . end ( ) , __den_vec . begin ( ) ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _RealType >
void
piecewise_linear_distribution < _RealType > :: param_type ::
_M_initialize ( )
{
if ( _M_int . size ( ) < 2
|| ( _M_int . size ( ) == 2
&& _M_int [ 0 ] == _RealType ( 0 )
&& _M_int [ 1 ] == _RealType ( 1 )
&& _M_den [ 0 ] == _M_den [ 1 ] ) )
{
_M_int . clear ( ) ;
_M_den . clear ( ) ;
return ;
}

double __sum = 0.0 ;
_M_cp . reserve ( _M_int . size ( ) - 1 ) ;
_M_m . reserve ( _M_int . size ( ) - 1 ) ;
for ( size_t __k = 0 ; __k < _M_int . size ( ) - 1 ; ++ __k )
{
const _RealType __delta = _M_int [ __k + 1 ] - _M_int [ __k ] ;
__sum += 0.5 * ( _M_den [ __k + 1 ] + _M_den [ __k ] ) * __delta ;
_M_cp . push_back ( __sum ) ;
_M_m . push_back ( ( _M_den [ __k + 1 ] - _M_den [ __k ] ) / __delta ) ;
}


__detail :: __normalize ( _M_den . begin ( ) , _M_den . end ( ) , _M_den . begin ( ) ,
__sum ) ;

__detail :: __normalize ( _M_cp . begin ( ) , _M_cp . end ( ) , _M_cp . begin ( ) , __sum ) ;

__detail :: __normalize ( _M_m . begin ( ) , _M_m . end ( ) , _M_m . begin ( ) , __sum ) ;


_M_cp [ _M_cp . size ( ) - 1 ] = 1.0 ;
}

template < typename _RealType >
template < typename _InputIteratorB , typename _InputIteratorW >
piecewise_linear_distribution < _RealType > :: param_type ::
param_type ( _InputIteratorB __bbegin ,
_InputIteratorB __bend ,
_InputIteratorW __wbegin )
: _M_int ( ) , _M_den ( ) , _M_cp ( ) , _M_m ( )
{
for ( ; __bbegin != __bend ; ++ __bbegin , ++ __wbegin )
{
_M_int . push_back ( * __bbegin ) ;
_M_den . push_back ( * __wbegin ) ;
}

_M_initialize ( ) ;
}

template < typename _RealType >
template < typename _Func >
piecewise_linear_distribution < _RealType > :: param_type ::
param_type ( initializer_list < _RealType > __bl , _Func __fw )
: _M_int ( ) , _M_den ( ) , _M_cp ( ) , _M_m ( )
{
_M_int . reserve ( __bl . size ( ) ) ;
_M_den . reserve ( __bl . size ( ) ) ;
for ( auto __biter = __bl . begin ( ) ; __biter != __bl . end ( ) ; ++ __biter )
{
_M_int . push_back ( * __biter ) ;
_M_den . push_back ( __fw ( * __biter ) ) ;
}

_M_initialize ( ) ;
}

template < typename _RealType >
template < typename _Func >
piecewise_linear_distribution < _RealType > :: param_type ::
param_type ( size_t __nw , _RealType __xmin , _RealType __xmax , _Func __fw )
: _M_int ( ) , _M_den ( ) , _M_cp ( ) , _M_m ( )
{
const size_t __n = __nw == 0 ? 1 : __nw ;
const _RealType __delta = ( __xmax - __xmin ) / __n ;

_M_int . reserve ( __n + 1 ) ;
_M_den . reserve ( __n + 1 ) ;
for ( size_t __k = 0 ; __k <= __nw ; ++ __k )
{
_M_int . push_back ( __xmin + __k * __delta ) ;
_M_den . push_back ( __fw ( _M_int [ __k ] + __delta ) ) ;
}

_M_initialize ( ) ;
}

template < typename _RealType >
template < typename _UniformRandomNumberGenerator >
typename piecewise_linear_distribution < _RealType > :: result_type
piecewise_linear_distribution < _RealType > ::
operator ( ) ( _UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{
__detail :: _Adaptor < _UniformRandomNumberGenerator , double >
__aurng ( __urng ) ;

const double __p = __aurng ( ) ;
if ( __param . _M_cp . empty ( ) )
return __p ;

auto __pos = std :: lower_bound ( __param . _M_cp . begin ( ) ,
__param . _M_cp . end ( ) , __p ) ;
const size_t __i = __pos - __param . _M_cp . begin ( ) ;

const double __pref = __i > 0 ? __param . _M_cp [ __i - 1 ] : 0.0 ;

const double __a = 0.5 * __param . _M_m [ __i ] ;
const double __b = __param . _M_den [ __i ] ;
const double __cm = __p - __pref ;

_RealType __x = __param . _M_int [ __i ] ;
if ( __a == 0 )
__x += __cm / __b ;
else
{
const double __d = __b * __b + 4.0 * __a * __cm ;
__x += 0.5 * ( std :: sqrt ( __d ) - __b ) / __a ;
}

return __x ;
}

template < typename _RealType >
template < typename _ForwardIterator ,
typename _UniformRandomNumberGenerator >
void
piecewise_linear_distribution < _RealType > ::
__generate_impl ( _ForwardIterator __f , _ForwardIterator __t ,
_UniformRandomNumberGenerator & __urng ,
const param_type & __param )
{


while ( __f != __t )
* __f ++ = this -> operator ( ) ( __urng , __param ) ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const piecewise_linear_distribution < _RealType > & __x )
{
typedef std :: basic_ostream < _CharT , _Traits > __ostream_type ;
typedef typename __ostream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __os . flags ( ) ;
const _CharT __fill = __os . fill ( ) ;
const std :: streamsize __precision = __os . precision ( ) ;
const _CharT __space = __os . widen ( ' ' ) ;
__os . flags ( __ios_base :: scientific | __ios_base :: left ) ;
__os . fill ( __space ) ;
__os . precision ( std :: numeric_limits < _RealType > :: max_digits10 ) ;

std :: vector < _RealType > __int = __x . intervals ( ) ;
__os << __int . size ( ) - 1 ;

for ( auto __xit = __int . begin ( ) ; __xit != __int . end ( ) ; ++ __xit )
__os << __space << * __xit ;

std :: vector < double > __den = __x . densities ( ) ;
for ( auto __dit = __den . begin ( ) ; __dit != __den . end ( ) ; ++ __dit )
__os << __space << * __dit ;

__os . flags ( __flags ) ;
__os . fill ( __fill ) ;
__os . precision ( __precision ) ;
return __os ;
}

template < typename _RealType , typename _CharT , typename _Traits >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is ,
piecewise_linear_distribution < _RealType > & __x )
{
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

const typename __ios_base :: fmtflags __flags = __is . flags ( ) ;
__is . flags ( __ios_base :: dec | __ios_base :: skipws ) ;

size_t __n ;
__is >> __n ;

std :: vector < _RealType > __int_vec ;
__int_vec . reserve ( __n + 1 ) ;
for ( size_t __i = 0 ; __i <= __n ; ++ __i )
{
_RealType __int ;
__is >> __int ;
__int_vec . push_back ( __int ) ;
}

std :: vector < double > __den_vec ;
__den_vec . reserve ( __n + 1 ) ;
for ( size_t __i = 0 ; __i <= __n ; ++ __i )
{
double __den ;
__is >> __den ;
__den_vec . push_back ( __den ) ;
}

__x . param ( typename piecewise_linear_distribution < _RealType > ::
param_type ( __int_vec . begin ( ) , __int_vec . end ( ) , __den_vec . begin ( ) ) ) ;

__is . flags ( __flags ) ;
return __is ;
}


template < typename _IntType >
seed_seq :: seed_seq ( std :: initializer_list < _IntType > __il )
{
for ( auto __iter = __il . begin ( ) ; __iter != __il . end ( ) ; ++ __iter )
_M_v . push_back ( __detail :: __mod < result_type ,
__detail :: _Shift < result_type , 32 > :: __value > ( * __iter ) ) ;
}

template < typename _InputIterator >
seed_seq :: seed_seq ( _InputIterator __begin , _InputIterator __end )
{
for ( _InputIterator __iter = __begin ; __iter != __end ; ++ __iter )
_M_v . push_back ( __detail :: __mod < result_type ,
__detail :: _Shift < result_type , 32 > :: __value > ( * __iter ) ) ;
}

template < typename _RandomAccessIterator >
void
seed_seq :: generate ( _RandomAccessIterator __begin ,
_RandomAccessIterator __end )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_Type ;

if ( __begin == __end )
return ;

std :: fill ( __begin , __end , _Type ( 0x8b8b8b8bu ) ) ;

const size_t __n = __end - __begin ;
const size_t __s = _M_v . size ( ) ;
const size_t __t = ( __n >= 623 ) ? 11
: ( __n >= 68 ) ? 7
: ( __n >= 39 ) ? 5
: ( __n >= 7 ) ? 3
: ( __n - 1 ) / 2 ;
const size_t __p = ( __n - __t ) / 2 ;
const size_t __q = __p + __t ;
const size_t __m = std :: max ( size_t ( __s + 1 ) , __n ) ;

for ( size_t __k = 0 ; __k < __m ; ++ __k )
{
_Type __arg = ( __begin [ __k % __n ]
^ __begin [ ( __k + __p ) % __n ]
^ __begin [ ( __k - 1 ) % __n ] ) ;
_Type __r1 = __arg ^ ( __arg >> 27 ) ;
__r1 = __detail :: __mod < _Type ,
__detail :: _Shift < _Type , 32 > :: __value > ( 1664525u * __r1 ) ;
_Type __r2 = __r1 ;
if ( __k == 0 )
__r2 += __s ;
else if ( __k <= __s )
__r2 += __k % __n + _M_v [ __k - 1 ] ;
else
__r2 += __k % __n ;
__r2 = __detail :: __mod < _Type ,
__detail :: _Shift < _Type , 32 > :: __value > ( __r2 ) ;
__begin [ ( __k + __p ) % __n ] += __r1 ;
__begin [ ( __k + __q ) % __n ] += __r2 ;
__begin [ __k % __n ] = __r2 ;
}

for ( size_t __k = __m ; __k < __m + __n ; ++ __k )
{
_Type __arg = ( __begin [ __k % __n ]
+ __begin [ ( __k + __p ) % __n ]
+ __begin [ ( __k - 1 ) % __n ] ) ;
_Type __r3 = __arg ^ ( __arg >> 27 ) ;
__r3 = __detail :: __mod < _Type ,
__detail :: _Shift < _Type , 32 > :: __value > ( 1566083941u * __r3 ) ;
_Type __r4 = __r3 - __k % __n ;
__r4 = __detail :: __mod < _Type ,
__detail :: _Shift < _Type , 32 > :: __value > ( __r4 ) ;
__begin [ ( __k + __p ) % __n ] ^= __r3 ;
__begin [ ( __k + __q ) % __n ] ^= __r4 ;
__begin [ __k % __n ] = __r4 ;
}
}

template < typename _RealType , size_t __bits ,
typename _UniformRandomNumberGenerator >
_RealType
generate_canonical ( _UniformRandomNumberGenerator & __urng )
{
const size_t __b
= std :: min ( static_cast < size_t > ( std :: numeric_limits < _RealType > :: digits ) ,
__bits ) ;
const long double __r = static_cast < long double > ( __urng . max ( ) )
- static_cast < long double > ( __urng . min ( ) ) + 1.0L ;
const size_t __log2r = std :: log ( __r ) / std :: log ( 2.0L ) ;
size_t __k = std :: max < size_t > ( 1UL , ( __b + __log2r - 1UL ) / __log2r ) ;
_RealType __sum = _RealType ( 0 ) ;
_RealType __tmp = _RealType ( 1 ) ;
for ( ; __k != 0 ; -- __k )
{
__sum += _RealType ( __urng ( ) - __urng . min ( ) ) * __tmp ;
__tmp *= __r ;
}
return __sum / __tmp ;
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/functional"
#46
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/typeinfo"
#32
#pragma GCC system_header
#39
#pragma GCC visibility push ( default )

extern "C++" {

namespace __cxxabiv1
{
class __class_type_info ;
}
#80
namespace std
{
#88
class type_info
{
public :




virtual ~ type_info ( ) ;



const char * name ( ) const noexcept
{ return __name [ 0 ] == '*' ? __name + 1 : __name ; }
#115
bool before ( const type_info & __arg ) const noexcept
{ return ( __name [ 0 ] == '*' && __arg . __name [ 0 ] == '*' )
? __name < __arg . __name
: __builtin_strcmp ( __name , __arg . __name ) < 0 ; }

bool operator == ( const type_info & __arg ) const noexcept
{
return ( ( __name == __arg . __name )
|| ( __name [ 0 ] != '*' &&
__builtin_strcmp ( __name , __arg . __name ) == 0 ) ) ;
}
#136
bool operator != ( const type_info & __arg ) const noexcept
{ return ! operator == ( __arg ) ; }


size_t hash_code ( ) const noexcept
{

return _Hash_bytes ( name ( ) , __builtin_strlen ( name ( ) ) ,
static_cast < size_t > ( 0xc70f6907UL ) ) ;



}



virtual bool __is_pointer_p ( ) const ;


virtual bool __is_function_p ( ) const ;
#163
virtual bool __do_catch ( const type_info * __thr_type , void * * __thr_obj ,
unsigned __outer ) const ;


virtual bool __do_upcast ( const __cxxabiv1 :: __class_type_info * __target ,
void * * __obj_ptr ) const ;

protected :
const char * __name ;

explicit type_info ( const char * __n ) : __name ( __n ) { }

private :

type_info & operator = ( const type_info & ) ;
type_info ( const type_info & ) ;
} ;
#187
class bad_cast : public exception
{
public :
bad_cast ( ) noexcept { }



virtual ~ bad_cast ( ) noexcept ;


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





class bad_typeid : public exception
{
public :
bad_typeid ( ) noexcept { }



virtual ~ bad_typeid ( ) noexcept ;


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

}

#pragma GCC visibility pop
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/tuple"
#32
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/include/CC/gnu/array"
#38
#pragma GCC system_header
#48
namespace std
{


template < typename _Tp , std :: size_t _Nm >
struct __array_traits
{
typedef _Tp _Type [ _Nm ] ;

static constexpr _Tp &
_S_ref ( const _Type & __t , std :: size_t __n ) noexcept
{ return const_cast < _Tp & > ( __t [ __n ] ) ; }
} ;

template < typename _Tp >
struct __array_traits < _Tp , 0 >
{
struct _Type { } ;

static constexpr _Tp &
_S_ref ( const _Type & , std :: size_t ) noexcept
{ return * static_cast < _Tp * > ( nullptr ) ; }
} ;
#86
template < typename _Tp , std :: size_t _Nm >
struct array
{
typedef _Tp value_type ;
typedef value_type * pointer ;
typedef const value_type * const_pointer ;
typedef value_type & reference ;
typedef const value_type & const_reference ;
typedef value_type * iterator ;
typedef const value_type * const_iterator ;
typedef std :: size_t size_type ;
typedef std :: ptrdiff_t difference_type ;
typedef std :: reverse_iterator < iterator > reverse_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;


typedef std :: __array_traits < _Tp , _Nm > _AT_Type ;
typename _AT_Type :: _Type _M_elems ;




void
fill ( const value_type & __u )
{ std :: fill_n ( begin ( ) , size ( ) , __u ) ; }

void
swap ( array & __other )
noexcept ( noexcept ( std :: swap ( std :: declval < _Tp & > ( ) , std :: declval < _Tp & > ( ) ) ) )
{ std :: swap_ranges ( begin ( ) , end ( ) , __other . begin ( ) ) ; }


iterator
begin ( ) noexcept
{ return iterator ( data ( ) ) ; }

const_iterator
begin ( ) const noexcept
{ return const_iterator ( data ( ) ) ; }

iterator
end ( ) noexcept
{ return iterator ( data ( ) + _Nm ) ; }

const_iterator
end ( ) const noexcept
{ return const_iterator ( data ( ) + _Nm ) ; }

reverse_iterator
rbegin ( ) noexcept
{ return reverse_iterator ( end ( ) ) ; }

const_reverse_iterator
rbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }

reverse_iterator
rend ( ) noexcept
{ return reverse_iterator ( begin ( ) ) ; }

const_reverse_iterator
rend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }

const_iterator
cbegin ( ) const noexcept
{ return const_iterator ( data ( ) ) ; }

const_iterator
cend ( ) const noexcept
{ return const_iterator ( data ( ) + _Nm ) ; }

const_reverse_iterator
crbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }

const_reverse_iterator
crend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }


constexpr size_type
size ( ) const noexcept { return _Nm ; }

constexpr size_type
max_size ( ) const noexcept { return _Nm ; }

constexpr bool
empty ( ) const noexcept { return size ( ) == 0 ; }


reference
operator [ ] ( size_type __n )
{ return _AT_Type :: _S_ref ( _M_elems , __n ) ; }

constexpr const_reference
operator [ ] ( size_type __n ) const noexcept
{ return _AT_Type :: _S_ref ( _M_elems , __n ) ; }

reference
at ( size_type __n )
{
if ( __n >= _Nm )
std :: __throw_out_of_range ( ( "array::at" ) ) ;
return _AT_Type :: _S_ref ( _M_elems , __n ) ;
}

constexpr const_reference
at ( size_type __n ) const
{


return __n < _Nm ? _AT_Type :: _S_ref ( _M_elems , __n )
: ( std :: __throw_out_of_range ( ( "array::at" ) ) ,
_AT_Type :: _S_ref ( _M_elems , 0 ) ) ;
}

reference
front ( )
{ return * begin ( ) ; }

constexpr const_reference
front ( ) const
{ return _AT_Type :: _S_ref ( _M_elems , 0 ) ; }

reference
back ( )
{ return _Nm ? * ( end ( ) - 1 ) : * end ( ) ; }

constexpr const_reference
back ( ) const
{
return _Nm ? _AT_Type :: _S_ref ( _M_elems , _Nm - 1 )
: _AT_Type :: _S_ref ( _M_elems , 0 ) ;
}

pointer
data ( ) noexcept
{ return std :: __addressof ( _AT_Type :: _S_ref ( _M_elems , 0 ) ) ; }

const_pointer
data ( ) const noexcept
{ return std :: __addressof ( _AT_Type :: _S_ref ( _M_elems , 0 ) ) ; }
} ;


template < typename _Tp , std :: size_t _Nm >
inline bool
operator == ( const array < _Tp , _Nm > & __one , const array < _Tp , _Nm > & __two )
{ return std :: equal ( __one . begin ( ) , __one . end ( ) , __two . begin ( ) ) ; }

template < typename _Tp , std :: size_t _Nm >
inline bool
operator != ( const array < _Tp , _Nm > & __one , const array < _Tp , _Nm > & __two )
{ return ! ( __one == __two ) ; }

template < typename _Tp , std :: size_t _Nm >
inline bool
operator < ( const array < _Tp , _Nm > & __a , const array < _Tp , _Nm > & __b )
{
return std :: lexicographical_compare ( __a . begin ( ) , __a . end ( ) ,
__b . begin ( ) , __b . end ( ) ) ;
}

template < typename _Tp , std :: size_t _Nm >
inline bool
operator > ( const array < _Tp , _Nm > & __one , const array < _Tp , _Nm > & __two )
{ return __two < __one ; }

template < typename _Tp , std :: size_t _Nm >
inline bool
operator <= ( const array < _Tp , _Nm > & __one , const array < _Tp , _Nm > & __two )
{ return ! ( __one > __two ) ; }

template < typename _Tp , std :: size_t _Nm >
inline bool
operator >= ( const array < _Tp , _Nm > & __one , const array < _Tp , _Nm > & __two )
{ return ! ( __one < __two ) ; }


template < typename _Tp , std :: size_t _Nm >
inline void
swap ( array < _Tp , _Nm > & __one , array < _Tp , _Nm > & __two )
noexcept ( noexcept ( __one . swap ( __two ) ) )
{ __one . swap ( __two ) ; }

template < std :: size_t _Int , typename _Tp , std :: size_t _Nm >
constexpr _Tp &
get ( array < _Tp , _Nm > & __arr ) noexcept
{
static_assert ( _Int < _Nm , "index is out of bounds" ) ;
return std :: __array_traits < _Tp , _Nm > ::
_S_ref ( __arr . _M_elems , _Int ) ;
}

template < std :: size_t _Int , typename _Tp , std :: size_t _Nm >
constexpr _Tp &&
get ( array < _Tp , _Nm > && __arr ) noexcept
{
static_assert ( _Int < _Nm , "index is out of bounds" ) ;
return std :: move ( get < _Int > ( __arr ) ) ;
}

template < std :: size_t _Int , typename _Tp , std :: size_t _Nm >
constexpr const _Tp &
get ( const array < _Tp , _Nm > & __arr ) noexcept
{
static_assert ( _Int < _Nm , "index is out of bounds" ) ;
return std :: __array_traits < _Tp , _Nm > ::
_S_ref ( __arr . _M_elems , _Int ) ;
}


}

namespace std
{





template < typename _Tp >
class tuple_size ;

template < typename _Tp , std :: size_t _Nm >
struct tuple_size < std :: array < _Tp , _Nm >>
: public integral_constant < std :: size_t , _Nm > { } ;


template < std :: size_t _Int , typename _Tp >
class tuple_element ;

template < std :: size_t _Int , typename _Tp , std :: size_t _Nm >
struct tuple_element < _Int , std :: array < _Tp , _Nm >>
{
static_assert ( _Int < _Nm , "index is out of bounds" ) ;
typedef _Tp type ;
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/uses_allocator.h"
#34
namespace std
{



struct allocator_arg_t { } ;

constexpr allocator_arg_t allocator_arg = allocator_arg_t ( ) ;

template < typename _Tp > class __has_allocator_type_helper : __sfinae_types { template < typename _Up > struct _Wrap_type
#43
{ } ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: allocator_type > * ) ; template < typename
#43
_Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) == 1 ; } ; template
#43
< typename _Tp > struct __has_allocator_type : integral_constant < bool , __has_allocator_type_helper < typename remove_cv
#43
< _Tp > :: type > :: value > { } ;

template < typename _Tp , typename _Alloc ,
bool = __has_allocator_type < _Tp > :: value >
struct __uses_allocator_helper
: public false_type { } ;

template < typename _Tp , typename _Alloc >
struct __uses_allocator_helper < _Tp , _Alloc , true >
: public integral_constant < bool , is_convertible < _Alloc ,
typename _Tp :: allocator_type > :: value >
{ } ;


template < typename _Tp , typename _Alloc >
struct uses_allocator
: public integral_constant < bool ,
__uses_allocator_helper < _Tp , _Alloc > :: value >
{ } ;

template < typename _Tp , typename _Alloc , typename ... _Args >
struct __uses_allocator_arg
: is_constructible < _Tp , _Alloc , _Args ... >
{ static_assert ( uses_allocator < _Tp , _Alloc > :: value , "uses allocator" ) ; } ;

struct __uses_alloc_base { } ;
struct __uses_alloc0 : __uses_alloc_base
{ struct _Anything { _Anything ( ... ) { } } _M_a ; } ;
template < typename _Alloc >
struct __uses_alloc1 : __uses_alloc_base { const _Alloc * _M_a ; } ;
template < typename _Alloc >
struct __uses_alloc2 : __uses_alloc_base { const _Alloc * _M_a ; } ;

template < bool , typename _Alloc , typename ... _Args >
struct __uses_alloc ;

template < typename _Tp , typename _Alloc , typename ... _Args >
struct __uses_alloc < true , _Tp , _Alloc , _Args ... >
: conditional <
is_constructible < _Tp , allocator_arg_t , _Alloc , _Args ... > :: value ,
__uses_alloc1 < _Alloc > ,
__uses_alloc2 < _Alloc >> :: type
{ } ;

template < typename _Tp , typename _Alloc , typename ... _Args >
struct __uses_alloc < false , _Tp , _Alloc , _Args ... >
: __uses_alloc0 { } ;

template < typename _Tp , typename _Alloc , typename ... _Args >
struct __uses_alloc_impl
: __uses_alloc < uses_allocator < _Tp , _Alloc > :: value , _Tp , _Alloc , _Args ... >
{ } ;

template < typename _Tp , typename _Alloc , typename ... _Args >
__uses_alloc_impl < _Tp , _Alloc , _Args ... >
__use_alloc ( const _Alloc & __a )
{
__uses_alloc_impl < _Tp , _Alloc , _Args ... > __ret ;
__ret . _M_a = & __a ;
return __ret ;
}


}
#42 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/tuple"
namespace std
{
#52
template < typename _Tp >
struct __add_c_ref
{ typedef const _Tp & type ; } ;

template < typename _Tp >
struct __add_c_ref < _Tp & >
{ typedef _Tp & type ; } ;


template < typename _Tp >
struct __add_ref
{ typedef _Tp & type ; } ;

template < typename _Tp >
struct __add_ref < _Tp & >
{ typedef _Tp & type ; } ;


template < typename _Tp >
struct __add_r_ref
{ typedef _Tp && type ; } ;

template < typename _Tp >
struct __add_r_ref < _Tp & >
{ typedef _Tp & type ; } ;

template < std :: size_t _Idx , typename _Head , bool _IsEmptyNotFinal >
struct _Head_base ;

template < std :: size_t _Idx , typename _Head >
struct _Head_base < _Idx , _Head , true >
: public _Head
{
constexpr _Head_base ( )
: _Head ( ) { }

constexpr _Head_base ( const _Head & __h )
: _Head ( __h ) { }

template < typename _UHead , typename = typename
enable_if < ! is_convertible < _UHead ,
__uses_alloc_base > :: value > :: type >
constexpr _Head_base ( _UHead && __h )
: _Head ( std :: forward < _UHead > ( __h ) ) { }

_Head_base ( __uses_alloc0 )
: _Head ( ) { }

template < typename _Alloc >
_Head_base ( __uses_alloc1 < _Alloc > __a )
: _Head ( allocator_arg , * __a . _M_a ) { }

template < typename _Alloc >
_Head_base ( __uses_alloc2 < _Alloc > __a )
: _Head ( * __a . _M_a ) { }

template < typename _UHead >
_Head_base ( __uses_alloc0 , _UHead && __uhead )
: _Head ( std :: forward < _UHead > ( __uhead ) ) { }

template < typename _Alloc , typename _UHead >
_Head_base ( __uses_alloc1 < _Alloc > __a , _UHead && __uhead )
: _Head ( allocator_arg , * __a . _M_a , std :: forward < _UHead > ( __uhead ) ) { }

template < typename _Alloc , typename _UHead >
_Head_base ( __uses_alloc2 < _Alloc > __a , _UHead && __uhead )
: _Head ( std :: forward < _UHead > ( __uhead ) , * __a . _M_a ) { }

static constexpr _Head &
_M_head ( _Head_base & __b ) noexcept { return __b ; }

static constexpr const _Head &
_M_head ( const _Head_base & __b ) noexcept { return __b ; }
} ;

template < std :: size_t _Idx , typename _Head >
struct _Head_base < _Idx , _Head , false >
{
constexpr _Head_base ( )
: _M_head_impl ( ) { }

constexpr _Head_base ( const _Head & __h )
: _M_head_impl ( __h ) { }

template < typename _UHead , typename = typename
enable_if < ! is_convertible < _UHead ,
__uses_alloc_base > :: value > :: type >
constexpr _Head_base ( _UHead && __h )
: _M_head_impl ( std :: forward < _UHead > ( __h ) ) { }

_Head_base ( __uses_alloc0 )
: _M_head_impl ( ) { }

template < typename _Alloc >
_Head_base ( __uses_alloc1 < _Alloc > __a )
: _M_head_impl ( allocator_arg , * __a . _M_a ) { }

template < typename _Alloc >
_Head_base ( __uses_alloc2 < _Alloc > __a )
: _M_head_impl ( * __a . _M_a ) { }

template < typename _UHead >
_Head_base ( __uses_alloc0 , _UHead && __uhead )
: _M_head_impl ( std :: forward < _UHead > ( __uhead ) ) { }

template < typename _Alloc , typename _UHead >
_Head_base ( __uses_alloc1 < _Alloc > __a , _UHead && __uhead )
: _M_head_impl ( allocator_arg , * __a . _M_a , std :: forward < _UHead > ( __uhead ) )
{ }

template < typename _Alloc , typename _UHead >
_Head_base ( __uses_alloc2 < _Alloc > __a , _UHead && __uhead )
: _M_head_impl ( std :: forward < _UHead > ( __uhead ) , * __a . _M_a ) { }

static constexpr _Head &
_M_head ( _Head_base & __b ) noexcept { return __b . _M_head_impl ; }

static constexpr const _Head &
_M_head ( const _Head_base & __b ) noexcept { return __b . _M_head_impl ; }

_Head _M_head_impl ;
} ;
#183
template < std :: size_t _Idx , typename ... _Elements >
struct _Tuple_impl ;





template < std :: size_t _Idx >
struct _Tuple_impl < _Idx >
{
template < std :: size_t , typename ... > friend class _Tuple_impl ;

_Tuple_impl ( ) = default ;

template < typename _Alloc >
_Tuple_impl ( allocator_arg_t , const _Alloc & ) { }

template < typename _Alloc >
_Tuple_impl ( allocator_arg_t , const _Alloc & , const _Tuple_impl & ) { }

template < typename _Alloc >
_Tuple_impl ( allocator_arg_t , const _Alloc & , _Tuple_impl && ) { }

protected :
void _M_swap ( _Tuple_impl & ) noexcept { }
} ;

template < typename _Tp >
struct __is_empty_non_tuple : is_empty < _Tp > { } ;


template < typename _El0 , typename ... _El >
struct __is_empty_non_tuple < tuple < _El0 , _El ... >> : false_type { } ;


template < typename _Tp >
using __empty_not_final
= typename conditional < __oracle_is_final ( _Tp ) , false_type ,
__is_empty_non_tuple < _Tp >> :: type ;
#228
template < std :: size_t _Idx , typename _Head , typename ... _Tail >
struct _Tuple_impl < _Idx , _Head , _Tail ... >
: public _Tuple_impl < _Idx + 1 , _Tail ... > ,
private _Head_base < _Idx , _Head , __empty_not_final < _Head > :: value >
{
template < std :: size_t , typename ... > friend class _Tuple_impl ;

typedef _Tuple_impl < _Idx + 1 , _Tail ... > _Inherited ;
typedef _Head_base < _Idx , _Head , __empty_not_final < _Head > :: value > _Base ;

static constexpr _Head &
_M_head ( _Tuple_impl & __t ) noexcept { return _Base :: _M_head ( __t ) ; }

static constexpr const _Head &
_M_head ( const _Tuple_impl & __t ) noexcept { return _Base :: _M_head ( __t ) ; }

static constexpr _Inherited &
_M_tail ( _Tuple_impl & __t ) noexcept { return __t ; }

static constexpr const _Inherited &
_M_tail ( const _Tuple_impl & __t ) noexcept { return __t ; }

constexpr _Tuple_impl ( )
: _Inherited ( ) , _Base ( ) { }

explicit
constexpr _Tuple_impl ( const _Head & __head , const _Tail & ... __tail )
: _Inherited ( __tail ... ) , _Base ( __head ) { }

template < typename _UHead , typename ... _UTail , typename = typename
enable_if < sizeof ... ( _Tail ) == sizeof ... ( _UTail ) > :: type >
explicit
constexpr _Tuple_impl ( _UHead && __head , _UTail && ... __tail )
: _Inherited ( std :: forward < _UTail > ( __tail ) ... ) ,
_Base ( std :: forward < _UHead > ( __head ) ) { }

constexpr _Tuple_impl ( const _Tuple_impl & ) = default ;

constexpr
_Tuple_impl ( _Tuple_impl && __in )
noexcept ( __and_ < is_nothrow_move_constructible < _Head > ,
is_nothrow_move_constructible < _Inherited >> :: value )
: _Inherited ( std :: move ( _M_tail ( __in ) ) ) ,
_Base ( std :: forward < _Head > ( _M_head ( __in ) ) ) { }

template < typename ... _UElements >
constexpr _Tuple_impl ( const _Tuple_impl < _Idx , _UElements ... > & __in )
: _Inherited ( _Tuple_impl < _Idx , _UElements ... > :: _M_tail ( __in ) ) ,
_Base ( _Tuple_impl < _Idx , _UElements ... > :: _M_head ( __in ) ) { }

template < typename _UHead , typename ... _UTails >
constexpr _Tuple_impl ( _Tuple_impl < _Idx , _UHead , _UTails ... > && __in )
: _Inherited ( std :: move
( _Tuple_impl < _Idx , _UHead , _UTails ... > :: _M_tail ( __in ) ) ) ,
_Base ( std :: forward < _UHead >
( _Tuple_impl < _Idx , _UHead , _UTails ... > :: _M_head ( __in ) ) ) { }

template < typename _Alloc >
_Tuple_impl ( allocator_arg_t __tag , const _Alloc & __a )
: _Inherited ( __tag , __a ) ,
_Base ( __use_alloc < _Head > ( __a ) ) { }

template < typename _Alloc >
_Tuple_impl ( allocator_arg_t __tag , const _Alloc & __a ,
const _Head & __head , const _Tail & ... __tail )
: _Inherited ( __tag , __a , __tail ... ) ,
_Base ( __use_alloc < _Head , _Alloc , _Head > ( __a ) , __head ) { }

template < typename _Alloc , typename _UHead , typename ... _UTail ,
typename = typename enable_if < sizeof ... ( _Tail )
== sizeof ... ( _UTail ) > :: type >
_Tuple_impl ( allocator_arg_t __tag , const _Alloc & __a ,
_UHead && __head , _UTail && ... __tail )
: _Inherited ( __tag , __a , std :: forward < _UTail > ( __tail ) ... ) ,
_Base ( __use_alloc < _Head , _Alloc , _UHead > ( __a ) ,
std :: forward < _UHead > ( __head ) ) { }

template < typename _Alloc >
_Tuple_impl ( allocator_arg_t __tag , const _Alloc & __a ,
const _Tuple_impl & __in )
: _Inherited ( __tag , __a , _M_tail ( __in ) ) ,
_Base ( __use_alloc < _Head , _Alloc , _Head > ( __a ) , _M_head ( __in ) ) { }

template < typename _Alloc >
_Tuple_impl ( allocator_arg_t __tag , const _Alloc & __a ,
_Tuple_impl && __in )
: _Inherited ( __tag , __a , std :: move ( _M_tail ( __in ) ) ) ,
_Base ( __use_alloc < _Head , _Alloc , _Head > ( __a ) ,
std :: forward < _Head > ( _M_head ( __in ) ) ) { }

template < typename _Alloc , typename ... _UElements >
_Tuple_impl ( allocator_arg_t __tag , const _Alloc & __a ,
const _Tuple_impl < _Idx , _UElements ... > & __in )
: _Inherited ( __tag , __a ,
_Tuple_impl < _Idx , _UElements ... > :: _M_tail ( __in ) ) ,
_Base ( __use_alloc < _Head , _Alloc , _Head > ( __a ) ,
_Tuple_impl < _Idx , _UElements ... > :: _M_head ( __in ) ) { }

template < typename _Alloc , typename _UHead , typename ... _UTails >
_Tuple_impl ( allocator_arg_t __tag , const _Alloc & __a ,
_Tuple_impl < _Idx , _UHead , _UTails ... > && __in )
: _Inherited ( __tag , __a , std :: move
( _Tuple_impl < _Idx , _UHead , _UTails ... > :: _M_tail ( __in ) ) ) ,
_Base ( __use_alloc < _Head , _Alloc , _UHead > ( __a ) ,
std :: forward < _UHead >
( _Tuple_impl < _Idx , _UHead , _UTails ... > :: _M_head ( __in ) ) ) { }

_Tuple_impl &
operator = ( const _Tuple_impl & __in )
{
_M_head ( * this ) = _M_head ( __in ) ;
_M_tail ( * this ) = _M_tail ( __in ) ;
return * this ;
}

_Tuple_impl &
operator = ( _Tuple_impl && __in )
noexcept ( __and_ < is_nothrow_move_assignable < _Head > ,
is_nothrow_move_assignable < _Inherited >> :: value )
{
_M_head ( * this ) = std :: forward < _Head > ( _M_head ( __in ) ) ;
_M_tail ( * this ) = std :: move ( _M_tail ( __in ) ) ;
return * this ;
}

template < typename ... _UElements >
_Tuple_impl &
operator = ( const _Tuple_impl < _Idx , _UElements ... > & __in )
{
_M_head ( * this ) = _Tuple_impl < _Idx , _UElements ... > :: _M_head ( __in ) ;
_M_tail ( * this ) = _Tuple_impl < _Idx , _UElements ... > :: _M_tail ( __in ) ;
return * this ;
}

template < typename _UHead , typename ... _UTails >
_Tuple_impl &
operator = ( _Tuple_impl < _Idx , _UHead , _UTails ... > && __in )
{
_M_head ( * this ) = std :: forward < _UHead >
( _Tuple_impl < _Idx , _UHead , _UTails ... > :: _M_head ( __in ) ) ;
_M_tail ( * this ) = std :: move
( _Tuple_impl < _Idx , _UHead , _UTails ... > :: _M_tail ( __in ) ) ;
return * this ;
}

protected :
void
_M_swap ( _Tuple_impl & __in )
noexcept ( noexcept ( swap ( std :: declval < _Head & > ( ) ,
std :: declval < _Head & > ( ) ) )
&& noexcept ( _M_tail ( __in ) . _M_swap ( _M_tail ( __in ) ) ) )
{
using std :: swap ;
swap ( _M_head ( * this ) , _M_head ( __in ) ) ;
_Inherited :: _M_swap ( _M_tail ( __in ) ) ;
}
} ;


template < typename ... _Elements >
class tuple : public _Tuple_impl < 0 , _Elements ... >
{
typedef _Tuple_impl < 0 , _Elements ... > _Inherited ;

public :
constexpr tuple ( )
: _Inherited ( ) { }

explicit
constexpr tuple ( const _Elements & ... __elements )
: _Inherited ( __elements ... ) { }

template < typename ... _UElements , typename = typename
enable_if < __and_ < is_convertible < _UElements ,
_Elements > ... > :: value > :: type >
explicit
constexpr tuple ( _UElements && ... __elements )
: _Inherited ( std :: forward < _UElements > ( __elements ) ... ) { }

constexpr tuple ( const tuple & ) = default ;

constexpr tuple ( tuple && ) = default ;

template < typename ... _UElements , typename = typename
enable_if < __and_ < is_convertible < const _UElements & ,
_Elements > ... > :: value > :: type >
constexpr tuple ( const tuple < _UElements ... > & __in )
: _Inherited ( static_cast < const _Tuple_impl < 0 , _UElements ... > & > ( __in ) )
{ }

template < typename ... _UElements , typename = typename
enable_if < __and_ < is_convertible < _UElements ,
_Elements > ... > :: value > :: type >
constexpr tuple ( tuple < _UElements ... > && __in )
: _Inherited ( static_cast < _Tuple_impl < 0 , _UElements ... > && > ( __in ) ) { }



template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a )
: _Inherited ( __tag , __a ) { }

template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a ,
const _Elements & ... __elements )
: _Inherited ( __tag , __a , __elements ... ) { }

template < typename _Alloc , typename ... _UElements , typename = typename
enable_if < sizeof ... ( _UElements )
== sizeof ... ( _Elements ) > :: type >
tuple ( allocator_arg_t __tag , const _Alloc & __a ,
_UElements && ... __elements )
: _Inherited ( __tag , __a , std :: forward < _UElements > ( __elements ) ... )
{ }

template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a , const tuple & __in )
: _Inherited ( __tag , __a , static_cast < const _Inherited & > ( __in ) ) { }

template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a , tuple && __in )
: _Inherited ( __tag , __a , static_cast < _Inherited && > ( __in ) ) { }

template < typename _Alloc , typename ... _UElements , typename = typename
enable_if < sizeof ... ( _UElements )
== sizeof ... ( _Elements ) > :: type >
tuple ( allocator_arg_t __tag , const _Alloc & __a ,
const tuple < _UElements ... > & __in )
: _Inherited ( __tag , __a ,
static_cast < const _Tuple_impl < 0 , _UElements ... > & > ( __in ) )
{ }

template < typename _Alloc , typename ... _UElements , typename = typename
enable_if < sizeof ... ( _UElements )
== sizeof ... ( _Elements ) > :: type >
tuple ( allocator_arg_t __tag , const _Alloc & __a ,
tuple < _UElements ... > && __in )
: _Inherited ( __tag , __a ,
static_cast < _Tuple_impl < 0 , _UElements ... > && > ( __in ) )
{ }

tuple &
operator = ( const tuple & __in )
{
static_cast < _Inherited & > ( * this ) = __in ;
return * this ;
}

tuple &
operator = ( tuple && __in )
noexcept ( is_nothrow_move_assignable < _Inherited > :: value )
{
static_cast < _Inherited & > ( * this ) = std :: move ( __in ) ;
return * this ;
}

template < typename ... _UElements , typename = typename
enable_if < sizeof ... ( _UElements )
== sizeof ... ( _Elements ) > :: type >
tuple &
operator = ( const tuple < _UElements ... > & __in )
{
static_cast < _Inherited & > ( * this ) = __in ;
return * this ;
}

template < typename ... _UElements , typename = typename
enable_if < sizeof ... ( _UElements )
== sizeof ... ( _Elements ) > :: type >
tuple &
operator = ( tuple < _UElements ... > && __in )
{
static_cast < _Inherited & > ( * this ) = std :: move ( __in ) ;
return * this ;
}

void
swap ( tuple & __in )
noexcept ( noexcept ( __in . _M_swap ( __in ) ) )
{ _Inherited :: _M_swap ( __in ) ; }
} ;


template < >
class tuple < >
{
public :
void swap ( tuple & ) noexcept { }
} ;



template < typename _T1 , typename _T2 >
class tuple < _T1 , _T2 > : public _Tuple_impl < 0 , _T1 , _T2 >
{
typedef _Tuple_impl < 0 , _T1 , _T2 > _Inherited ;

public :
constexpr tuple ( )
: _Inherited ( ) { }

explicit
constexpr tuple ( const _T1 & __a1 , const _T2 & __a2 )
: _Inherited ( __a1 , __a2 ) { }

template < typename _U1 , typename _U2 , typename = typename
enable_if < __and_ < is_convertible < _U1 , _T1 > ,
is_convertible < _U2 , _T2 >> :: value > :: type >
explicit
constexpr tuple ( _U1 && __a1 , _U2 && __a2 )
: _Inherited ( std :: forward < _U1 > ( __a1 ) , std :: forward < _U2 > ( __a2 ) ) { }

constexpr tuple ( const tuple & ) = default ;

constexpr tuple ( tuple && ) = default ;

template < typename _U1 , typename _U2 , typename = typename
enable_if < __and_ < is_convertible < const _U1 & , _T1 > ,
is_convertible < const _U2 & , _T2 >> :: value > :: type >
constexpr tuple ( const tuple < _U1 , _U2 > & __in )
: _Inherited ( static_cast < const _Tuple_impl < 0 , _U1 , _U2 > & > ( __in ) ) { }

template < typename _U1 , typename _U2 , typename = typename
enable_if < __and_ < is_convertible < _U1 , _T1 > ,
is_convertible < _U2 , _T2 >> :: value > :: type >
constexpr tuple ( tuple < _U1 , _U2 > && __in )
: _Inherited ( static_cast < _Tuple_impl < 0 , _U1 , _U2 > && > ( __in ) ) { }

template < typename _U1 , typename _U2 , typename = typename
enable_if < __and_ < is_convertible < const _U1 & , _T1 > ,
is_convertible < const _U2 & , _T2 >> :: value > :: type >
constexpr tuple ( const pair < _U1 , _U2 > & __in )
: _Inherited ( __in . first , __in . second ) { }

template < typename _U1 , typename _U2 , typename = typename
enable_if < __and_ < is_convertible < _U1 , _T1 > ,
is_convertible < _U2 , _T2 >> :: value > :: type >
constexpr tuple ( pair < _U1 , _U2 > && __in )
: _Inherited ( std :: forward < _U1 > ( __in . first ) ,
std :: forward < _U2 > ( __in . second ) ) { }



template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a )
: _Inherited ( __tag , __a ) { }

template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a ,
const _T1 & __a1 , const _T2 & __a2 )
: _Inherited ( __tag , __a , __a1 , __a2 ) { }

template < typename _Alloc , typename _U1 , typename _U2 >
tuple ( allocator_arg_t __tag , const _Alloc & __a , _U1 && __a1 , _U2 && __a2 )
: _Inherited ( __tag , __a , std :: forward < _U1 > ( __a1 ) ,
std :: forward < _U2 > ( __a2 ) ) { }

template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a , const tuple & __in )
: _Inherited ( __tag , __a , static_cast < const _Inherited & > ( __in ) ) { }

template < typename _Alloc >
tuple ( allocator_arg_t __tag , const _Alloc & __a , tuple && __in )
: _Inherited ( __tag , __a , static_cast < _Inherited && > ( __in ) ) { }

template < typename _Alloc , typename _U1 , typename _U2 >
tuple ( allocator_arg_t __tag , const _Alloc & __a ,
const tuple < _U1 , _U2 > & __in )
: _Inherited ( __tag , __a ,
static_cast < const _Tuple_impl < 0 , _U1 , _U2 > & > ( __in ) )
{ }

template < typename _Alloc , typename _U1 , typename _U2 >
tuple ( allocator_arg_t __tag , const _Alloc & __a , tuple < _U1 , _U2 > && __in )
: _Inherited ( __tag , __a , static_cast < _Tuple_impl < 0 , _U1 , _U2 > && > ( __in ) )
{ }

template < typename _Alloc , typename _U1 , typename _U2 >
tuple ( allocator_arg_t __tag , const _Alloc & __a ,
const pair < _U1 , _U2 > & __in )
: _Inherited ( __tag , __a , __in . first , __in . second ) { }

template < typename _Alloc , typename _U1 , typename _U2 >
tuple ( allocator_arg_t __tag , const _Alloc & __a , pair < _U1 , _U2 > && __in )
: _Inherited ( __tag , __a , std :: forward < _U1 > ( __in . first ) ,
std :: forward < _U2 > ( __in . second ) ) { }

tuple &
operator = ( const tuple & __in )
{
static_cast < _Inherited & > ( * this ) = __in ;
return * this ;
}

tuple &
operator = ( tuple && __in )
noexcept ( is_nothrow_move_assignable < _Inherited > :: value )
{
static_cast < _Inherited & > ( * this ) = std :: move ( __in ) ;
return * this ;
}

template < typename _U1 , typename _U2 >
tuple &
operator = ( const tuple < _U1 , _U2 > & __in )
{
static_cast < _Inherited & > ( * this ) = __in ;
return * this ;
}

template < typename _U1 , typename _U2 >
tuple &
operator = ( tuple < _U1 , _U2 > && __in )
{
static_cast < _Inherited & > ( * this ) = std :: move ( __in ) ;
return * this ;
}

template < typename _U1 , typename _U2 >
tuple &
operator = ( const pair < _U1 , _U2 > & __in )
{
this -> _M_head ( * this ) = __in . first ;
this -> _M_tail ( * this ) . _M_head ( * this ) = __in . second ;
return * this ;
}

template < typename _U1 , typename _U2 >
tuple &
operator = ( pair < _U1 , _U2 > && __in )
{
this -> _M_head ( * this ) = std :: forward < _U1 > ( __in . first ) ;
this -> _M_tail ( * this ) . _M_head ( * this ) = std :: forward < _U2 > ( __in . second ) ;
return * this ;
}

void
swap ( tuple & __in )
noexcept ( noexcept ( __in . _M_swap ( __in ) ) )
{ _Inherited :: _M_swap ( __in ) ; }
} ;



template < std :: size_t __i , typename _Tp >
struct tuple_element ;





template < std :: size_t __i , typename _Head , typename ... _Tail >
struct tuple_element < __i , tuple < _Head , _Tail ... > >
: tuple_element < __i - 1 , tuple < _Tail ... > > { } ;




template < typename _Head , typename ... _Tail >
struct tuple_element < 0 , tuple < _Head , _Tail ... > >
{
typedef _Head type ;
} ;

template < std :: size_t __i , typename _Tp >
struct tuple_element < __i , const _Tp >
{
typedef typename
add_const < typename tuple_element < __i , _Tp > :: type > :: type type ;
} ;

template < std :: size_t __i , typename _Tp >
struct tuple_element < __i , volatile _Tp >
{
typedef typename
add_volatile < typename tuple_element < __i , _Tp > :: type > :: type type ;
} ;

template < std :: size_t __i , typename _Tp >
struct tuple_element < __i , const volatile _Tp >
{
typedef typename
add_cv < typename tuple_element < __i , _Tp > :: type > :: type type ;
} ;


template < typename _Tp >
struct tuple_size ;

template < typename _Tp >
struct tuple_size < const _Tp >
: public integral_constant <
typename remove_cv < decltype ( tuple_size < _Tp > :: value ) > :: type ,
tuple_size < _Tp > :: value > { } ;

template < typename _Tp >
struct tuple_size < volatile _Tp >
: public integral_constant <
typename remove_cv < decltype ( tuple_size < _Tp > :: value ) > :: type ,
tuple_size < _Tp > :: value > { } ;

template < typename _Tp >
struct tuple_size < const volatile _Tp >
: public integral_constant <
typename remove_cv < decltype ( tuple_size < _Tp > :: value ) > :: type ,
tuple_size < _Tp > :: value > { } ;


template < typename ... _Elements >
struct tuple_size < tuple < _Elements ... >>
: public integral_constant < std :: size_t , sizeof ... ( _Elements ) > { } ;

template < std :: size_t __i , typename _Head , typename ... _Tail >
constexpr typename __add_ref < _Head > :: type
__get_helper ( _Tuple_impl < __i , _Head , _Tail ... > & __t ) noexcept
{ return _Tuple_impl < __i , _Head , _Tail ... > :: _M_head ( __t ) ; }

template < std :: size_t __i , typename _Head , typename ... _Tail >
constexpr typename __add_c_ref < _Head > :: type
__get_helper ( const _Tuple_impl < __i , _Head , _Tail ... > & __t ) noexcept
{ return _Tuple_impl < __i , _Head , _Tail ... > :: _M_head ( __t ) ; }




template < std :: size_t __i , typename ... _Elements >
constexpr typename __add_ref <
typename tuple_element < __i , tuple < _Elements ... >> :: type
> :: type
get ( tuple < _Elements ... > & __t ) noexcept
{ return __get_helper < __i > ( __t ) ; }

template < std :: size_t __i , typename ... _Elements >
constexpr typename __add_c_ref <
typename tuple_element < __i , tuple < _Elements ... >> :: type
> :: type
get ( const tuple < _Elements ... > & __t ) noexcept
{ return __get_helper < __i > ( __t ) ; }

template < std :: size_t __i , typename ... _Elements >
constexpr typename __add_r_ref <
typename tuple_element < __i , tuple < _Elements ... >> :: type
> :: type
get ( tuple < _Elements ... > && __t ) noexcept
{ return std :: forward < typename tuple_element < __i ,
tuple < _Elements ... >> :: type && > ( get < __i > ( __t ) ) ; }


template < std :: size_t __check_equal_size , std :: size_t __i , std :: size_t __j ,
typename _Tp , typename _Up >
struct __tuple_compare ;

template < std :: size_t __i , std :: size_t __j , typename _Tp , typename _Up >
struct __tuple_compare < 0 , __i , __j , _Tp , _Up >
{
static constexpr bool
__eq ( const _Tp & __t , const _Up & __u )
{
return ( get < __i > ( __t ) == get < __i > ( __u ) &&
__tuple_compare < 0 , __i + 1 , __j , _Tp , _Up > :: __eq ( __t , __u ) ) ;
}

static constexpr bool
__less ( const _Tp & __t , const _Up & __u )
{
return ( ( get < __i > ( __t ) < get < __i > ( __u ) )
|| ! ( get < __i > ( __u ) < get < __i > ( __t ) ) &&
__tuple_compare < 0 , __i + 1 , __j , _Tp , _Up > :: __less ( __t , __u ) ) ;
}
} ;

template < std :: size_t __i , typename _Tp , typename _Up >
struct __tuple_compare < 0 , __i , __i , _Tp , _Up >
{
static constexpr bool
__eq ( const _Tp & , const _Up & ) { return true ; }

static constexpr bool
__less ( const _Tp & , const _Up & ) { return false ; }
} ;

template < typename ... _TElements , typename ... _UElements >
constexpr bool
operator == ( const tuple < _TElements ... > & __t ,
const tuple < _UElements ... > & __u )
{
typedef tuple < _TElements ... > _Tp ;
typedef tuple < _UElements ... > _Up ;
return bool ( __tuple_compare < tuple_size < _Tp > :: value - tuple_size < _Up > :: value ,
0 , tuple_size < _Tp > :: value , _Tp , _Up > :: __eq ( __t , __u ) ) ;
}

template < typename ... _TElements , typename ... _UElements >
constexpr bool
operator < ( const tuple < _TElements ... > & __t ,
const tuple < _UElements ... > & __u )
{
typedef tuple < _TElements ... > _Tp ;
typedef tuple < _UElements ... > _Up ;
return bool ( __tuple_compare < tuple_size < _Tp > :: value - tuple_size < _Up > :: value ,
0 , tuple_size < _Tp > :: value , _Tp , _Up > :: __less ( __t , __u ) ) ;
}

template < typename ... _TElements , typename ... _UElements >
inline constexpr bool
operator != ( const tuple < _TElements ... > & __t ,
const tuple < _UElements ... > & __u )
{ return ! ( __t == __u ) ; }

template < typename ... _TElements , typename ... _UElements >
inline constexpr bool
operator > ( const tuple < _TElements ... > & __t ,
const tuple < _UElements ... > & __u )
{ return __u < __t ; }

template < typename ... _TElements , typename ... _UElements >
inline constexpr bool
operator <= ( const tuple < _TElements ... > & __t ,
const tuple < _UElements ... > & __u )
{ return ! ( __u < __t ) ; }

template < typename ... _TElements , typename ... _UElements >
inline constexpr bool
operator >= ( const tuple < _TElements ... > & __t ,
const tuple < _UElements ... > & __u )
{ return ! ( __t < __u ) ; }


template < typename ... _Elements >
constexpr tuple < typename __decay_and_strip < _Elements > :: __type ... >
make_tuple ( _Elements && ... __args )
{
typedef tuple < typename __decay_and_strip < _Elements > :: __type ... >
__result_type ;
return __result_type ( std :: forward < _Elements > ( __args ) ... ) ;
}

template < typename ... _Elements >
tuple < _Elements && ... >
forward_as_tuple ( _Elements && ... __args ) noexcept
{ return tuple < _Elements && ... > ( std :: forward < _Elements > ( __args ) ... ) ; }

template < typename >
struct __is_tuple_like_impl : false_type
{ } ;

template < typename ... _Tps >
struct __is_tuple_like_impl < tuple < _Tps ... >> : true_type
{ } ;

template < typename _T1 , typename _T2 >
struct __is_tuple_like_impl < pair < _T1 , _T2 >> : true_type
{ } ;

template < typename _Tp , std :: size_t _Nm >
struct __is_tuple_like_impl < array < _Tp , _Nm >> : true_type
{ } ;


template < typename _Tp >
struct __is_tuple_like
: public __is_tuple_like_impl < typename std :: remove_cv
< typename std :: remove_reference < _Tp > :: type > :: type > :: type
{ } ;



template < std :: size_t ... _Indexes >
struct _Index_tuple
{
typedef _Index_tuple < _Indexes ... , sizeof ... ( _Indexes ) > __next ;
} ;


template < std :: size_t _Num >
struct _Build_index_tuple
{
typedef typename _Build_index_tuple < _Num - 1 > :: __type :: __next __type ;
} ;

template < >
struct _Build_index_tuple < 0 >
{
typedef _Index_tuple < > __type ;
} ;

template < std :: size_t , typename , typename , std :: size_t >
struct __make_tuple_impl ;

template < std :: size_t _Idx , typename _Tuple , typename ... _Tp ,
std :: size_t _Nm >
struct __make_tuple_impl < _Idx , tuple < _Tp ... > , _Tuple , _Nm >
{
typedef typename __make_tuple_impl < _Idx + 1 , tuple < _Tp ... ,
typename std :: tuple_element < _Idx , _Tuple > :: type > , _Tuple , _Nm > :: __type
__type ;
} ;

template < std :: size_t _Nm , typename _Tuple , typename ... _Tp >
struct __make_tuple_impl < _Nm , tuple < _Tp ... > , _Tuple , _Nm >
{
typedef tuple < _Tp ... > __type ;
} ;

template < typename _Tuple >
struct __do_make_tuple
: public __make_tuple_impl < 0 , tuple < > , _Tuple ,
std :: tuple_size < _Tuple > :: value >
{ } ;


template < typename _Tuple >
struct __make_tuple
: public __do_make_tuple < typename std :: remove_cv
< typename std :: remove_reference < _Tuple > :: type > :: type >
{ } ;


template < typename ... >
struct __combine_tuples ;

template < >
struct __combine_tuples < >
{
typedef tuple < > __type ;
} ;

template < typename ... _Ts >
struct __combine_tuples < tuple < _Ts ... >>
{
typedef tuple < _Ts ... > __type ;
} ;

template < typename ... _T1s , typename ... _T2s , typename ... _Rem >
struct __combine_tuples < tuple < _T1s ... > , tuple < _T2s ... > , _Rem ... >
{
typedef typename __combine_tuples < tuple < _T1s ... , _T2s ... > ,
_Rem ... > :: __type __type ;
} ;


template < typename ... _Tpls >
struct __tuple_cat_result
{
typedef typename __combine_tuples
< typename __make_tuple < _Tpls > :: __type ... > :: __type __type ;
} ;



template < typename ... >
struct __make_1st_indices ;

template < >
struct __make_1st_indices < >
{
typedef std :: _Index_tuple < > __type ;
} ;

template < typename _Tp , typename ... _Tpls >
struct __make_1st_indices < _Tp , _Tpls ... >
{
typedef typename std :: _Build_index_tuple < std :: tuple_size <
typename std :: remove_reference < _Tp > :: type > :: value > :: __type __type ;
} ;




template < typename _Ret , typename _Indices , typename ... _Tpls >
struct __tuple_concater ;

template < typename _Ret , std :: size_t ... _Is , typename _Tp , typename ... _Tpls >
struct __tuple_concater < _Ret , std :: _Index_tuple < _Is ... > , _Tp , _Tpls ... >
{
template < typename ... _Us >
static constexpr _Ret
_S_do ( _Tp && __tp , _Tpls && ... __tps , _Us && ... __us )
{
typedef typename __make_1st_indices < _Tpls ... > :: __type __idx ;
typedef __tuple_concater < _Ret , __idx , _Tpls ... > __next ;
return __next :: _S_do ( std :: forward < _Tpls > ( __tps ) ... ,
std :: forward < _Us > ( __us ) ... ,
std :: get < _Is > ( std :: forward < _Tp > ( __tp ) ) ... ) ;
}
} ;

template < typename _Ret >
struct __tuple_concater < _Ret , std :: _Index_tuple < >>
{
template < typename ... _Us >
static constexpr _Ret
_S_do ( _Us && ... __us )
{
return _Ret ( std :: forward < _Us > ( __us ) ... ) ;
}
} ;


template < typename ... _Tpls , typename = typename
enable_if < __and_ < __is_tuple_like < _Tpls > ... > :: value > :: type >
constexpr auto
tuple_cat ( _Tpls && ... __tpls )
-> typename __tuple_cat_result < _Tpls ... > :: __type
{
typedef typename __tuple_cat_result < _Tpls ... > :: __type __ret ;
typedef typename __make_1st_indices < _Tpls ... > :: __type __idx ;
typedef __tuple_concater < __ret , __idx , _Tpls ... > __concater ;
return __concater :: _S_do ( std :: forward < _Tpls > ( __tpls ) ... ) ;
}


template < typename ... _Elements >
inline tuple < _Elements & ... >
tie ( _Elements & ... __args ) noexcept
{ return tuple < _Elements & ... > ( __args ... ) ; }


template < typename ... _Elements >
inline void
swap ( tuple < _Elements ... > & __x , tuple < _Elements ... > & __y )
noexcept ( noexcept ( __x . swap ( __y ) ) )
{ __x . swap ( __y ) ; }



struct _Swallow_assign
{
template < class _Tp >
const _Swallow_assign &
operator = ( const _Tp & ) const
{ return * this ; }
} ;

const _Swallow_assign ignore { } ;


template < typename ... _Types , typename _Alloc >
struct uses_allocator < tuple < _Types ... > , _Alloc > : true_type { } ;


template < class _T1 , class _T2 >
template < typename ... _Args1 , typename ... _Args2 >
inline
pair < _T1 , _T2 > ::
pair ( piecewise_construct_t ,
tuple < _Args1 ... > __first , tuple < _Args2 ... > __second )
: pair ( __first , __second ,
typename _Build_index_tuple < sizeof ... ( _Args1 ) > :: __type ( ) ,
typename _Build_index_tuple < sizeof ... ( _Args2 ) > :: __type ( ) )
{ }

template < class _T1 , class _T2 >
template < typename ... _Args1 , std :: size_t ... _Indexes1 ,
typename ... _Args2 , std :: size_t ... _Indexes2 >
inline
pair < _T1 , _T2 > ::
pair ( tuple < _Args1 ... > & __tuple1 , tuple < _Args2 ... > & __tuple2 ,
_Index_tuple < _Indexes1 ... > , _Index_tuple < _Indexes2 ... > )
: first ( std :: forward < _Args1 > ( std :: get < _Indexes1 > ( __tuple1 ) ) ... ) ,
second ( std :: forward < _Args2 > ( std :: get < _Indexes2 > ( __tuple2 ) ) ... )
{ }




}
#60 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/functional"
namespace std
{


template < typename _MemberPointer >
class _Mem_fn ;
template < typename _Tp , typename _Class >
_Mem_fn < _Tp _Class :: * >
mem_fn ( _Tp _Class :: * ) noexcept ;

template < typename _Tp > class __has_result_type_helper : __sfinae_types { template < typename _Up > struct _Wrap_type {
#70
} ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: result_type > * ) ; template < typename
#70
_Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) == 1 ; } ; template
#70
< typename _Tp > struct __has_result_type : integral_constant < bool , __has_result_type_helper < typename remove_cv < _Tp
#70
> :: type > :: value > { } ;


template < bool _Has_result_type , typename _Functor >
struct _Maybe_get_result_type
{ } ;

template < typename _Functor >
struct _Maybe_get_result_type < true , _Functor >
{ typedef typename _Functor :: result_type result_type ; } ;





template < typename _Functor >
struct _Weak_result_type_impl
: _Maybe_get_result_type < __has_result_type < _Functor > :: value , _Functor >
{ } ;


template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ) >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ... ) >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ) const >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ... ) const >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ) volatile >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ... ) volatile >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ) const volatile >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _ArgTypes ... ... ) const volatile >
{ typedef _Res result_type ; } ;


template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( & ) ( _ArgTypes ... ) >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( & ) ( _ArgTypes ... ... ) >
{ typedef _Res result_type ; } ;


template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( * ) ( _ArgTypes ... ) >
{ typedef _Res result_type ; } ;

template < typename _Res , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( * ) ( _ArgTypes ... ... ) >
{ typedef _Res result_type ; } ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... ) >
{ typedef _Res result_type ; } ;

template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... ... ) >
{ typedef _Res result_type ; } ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... ) const >
{ typedef _Res result_type ; } ;

template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... ... ) const >
{ typedef _Res result_type ; } ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... ) volatile >
{ typedef _Res result_type ; } ;

template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... ... ) volatile >
{ typedef _Res result_type ; } ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... )
const volatile >
{ typedef _Res result_type ; } ;

template < typename _Res , typename _Class , typename ... _ArgTypes >
struct _Weak_result_type_impl < _Res ( _Class :: * ) ( _ArgTypes ... ... )
const volatile >
{ typedef _Res result_type ; } ;





template < typename _Functor >
struct _Weak_result_type
: _Weak_result_type_impl < typename remove_cv < _Functor > :: type >
{ } ;


template < typename _Tp >
struct _Derives_from_unary_function : __sfinae_types
{
private :
template < typename _T1 , typename _Res >
static __one __test ( const volatile unary_function < _T1 , _Res > * ) ;



static __two __test ( ... ) ;

public :
static const bool value = sizeof ( __test ( ( _Tp * ) 0 ) ) == 1 ;
} ;


template < typename _Tp >
struct _Derives_from_binary_function : __sfinae_types
{
private :
template < typename _T1 , typename _T2 , typename _Res >
static __one __test ( const volatile binary_function < _T1 , _T2 , _Res > * ) ;



static __two __test ( ... ) ;

public :
static const bool value = sizeof ( __test ( ( _Tp * ) 0 ) ) == 1 ;
} ;





template < typename _Functor , typename ... _Args >
inline
typename enable_if <
( ! is_member_pointer < _Functor > :: value
&& ! is_function < _Functor > :: value
&& ! is_function < typename remove_pointer < _Functor > :: type > :: value ) ,
typename result_of < _Functor & ( _Args && ... ) > :: type
> :: type
__invoke ( _Functor & __f , _Args && ... __args )
{
return __f ( std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Functor , typename ... _Args >
inline
typename enable_if <
( is_member_pointer < _Functor > :: value
&& ! is_function < _Functor > :: value
&& ! is_function < typename remove_pointer < _Functor > :: type > :: value ) ,
typename result_of < _Functor ( _Args && ... ) > :: type
> :: type
__invoke ( _Functor & __f , _Args && ... __args )
{
return std :: mem_fn ( __f ) ( std :: forward < _Args > ( __args ) ... ) ;
}


template < typename _Functor , typename ... _Args >
inline
typename enable_if <
( is_pointer < _Functor > :: value
&& is_function < typename remove_pointer < _Functor > :: type > :: value ) ,
typename result_of < _Functor ( _Args && ... ) > :: type
> :: type
__invoke ( _Functor __f , _Args && ... __args )
{
return __f ( std :: forward < _Args > ( __args ) ... ) ;
}
#268
template < bool _Unary , bool _Binary , typename _Tp >
struct _Reference_wrapper_base_impl ;


template < typename _Tp >
struct _Reference_wrapper_base_impl < false , false , _Tp >
: _Weak_result_type < _Tp >
{ } ;


template < typename _Tp >
struct _Reference_wrapper_base_impl < true , false , _Tp >
: _Weak_result_type < _Tp >
{
typedef typename _Tp :: argument_type argument_type ;
} ;


template < typename _Tp >
struct _Reference_wrapper_base_impl < false , true , _Tp >
: _Weak_result_type < _Tp >
{
typedef typename _Tp :: first_argument_type first_argument_type ;
typedef typename _Tp :: second_argument_type second_argument_type ;
} ;


template < typename _Tp >
struct _Reference_wrapper_base_impl < true , true , _Tp >
: _Weak_result_type < _Tp >
{
typedef typename _Tp :: argument_type argument_type ;
typedef typename _Tp :: first_argument_type first_argument_type ;
typedef typename _Tp :: second_argument_type second_argument_type ;
} ;

template < typename _Tp > class __has_argument_type_helper : __sfinae_types { template < typename _Up > struct _Wrap_type
#304
{ } ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: argument_type > * ) ; template < typename
#304
_Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) == 1 ; } ; template
#304
< typename _Tp > struct __has_argument_type : integral_constant < bool , __has_argument_type_helper < typename remove_cv
#304
< _Tp > :: type > :: value > { } ;
template < typename _Tp > class __has_first_argument_type_helper : __sfinae_types { template < typename _Up > struct _Wrap_type
#305
{ } ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: first_argument_type > * ) ; template <
#305
typename _Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) == 1
#305
; } ; template < typename _Tp > struct __has_first_argument_type : integral_constant < bool , __has_first_argument_type_helper
#305
< typename remove_cv < _Tp > :: type > :: value > { } ;
template < typename _Tp > class __has_second_argument_type_helper : __sfinae_types { template < typename _Up > struct _Wrap_type
#306
{ } ; template < typename _Up > static __one __test ( _Wrap_type < typename _Up :: second_argument_type > * ) ; template
#306
< typename _Up > static __two __test ( ... ) ; public : static constexpr bool value = sizeof ( __test < _Tp > ( 0 ) ) ==
#306
1 ; } ; template < typename _Tp > struct __has_second_argument_type : integral_constant < bool , __has_second_argument_type_helper
#306
< typename remove_cv < _Tp > :: type > :: value > { } ;
#314
template < typename _Tp >
struct _Reference_wrapper_base
: _Reference_wrapper_base_impl <
__has_argument_type < _Tp > :: value ,
__has_first_argument_type < _Tp > :: value
&& __has_second_argument_type < _Tp > :: value ,
_Tp >
{ } ;


template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 ) >
: unary_function < _T1 , _Res >
{ } ;

template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 ) const >
: unary_function < _T1 , _Res >
{ } ;

template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 ) volatile >
: unary_function < _T1 , _Res >
{ } ;

template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 ) const volatile >
: unary_function < _T1 , _Res >
{ } ;


template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 , _T2 ) >
: binary_function < _T1 , _T2 , _Res >
{ } ;

template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 , _T2 ) const >
: binary_function < _T1 , _T2 , _Res >
{ } ;

template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 , _T2 ) volatile >
: binary_function < _T1 , _T2 , _Res >
{ } ;

template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 , _T2 ) const volatile >
: binary_function < _T1 , _T2 , _Res >
{ } ;


template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( * ) ( _T1 ) >
: unary_function < _T1 , _Res >
{ } ;


template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( * ) ( _T1 , _T2 ) >
: binary_function < _T1 , _T2 , _Res >
{ } ;


template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( ) >
: unary_function < _T1 * , _Res >
{ } ;


template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( _T2 ) >
: binary_function < _T1 * , _T2 , _Res >
{ } ;


template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( ) const >
: unary_function < const _T1 * , _Res >
{ } ;


template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( _T2 ) const >
: binary_function < const _T1 * , _T2 , _Res >
{ } ;


template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( ) volatile >
: unary_function < volatile _T1 * , _Res >
{ } ;


template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( _T2 ) volatile >
: binary_function < volatile _T1 * , _T2 , _Res >
{ } ;


template < typename _Res , typename _T1 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( ) const volatile >
: unary_function < const volatile _T1 * , _Res >
{ } ;


template < typename _Res , typename _T1 , typename _T2 >
struct _Reference_wrapper_base < _Res ( _T1 :: * ) ( _T2 ) const volatile >
: binary_function < const volatile _T1 * , _T2 , _Res >
{ } ;
#430
template < typename _Tp >
class reference_wrapper
: public _Reference_wrapper_base < typename remove_cv < _Tp > :: type >
{
_Tp * _M_data ;

public :
typedef _Tp type ;

reference_wrapper ( _Tp & __indata ) noexcept
: _M_data ( std :: __addressof ( __indata ) )
{ }

reference_wrapper ( _Tp && ) = delete ;

reference_wrapper ( const reference_wrapper < _Tp > & __inref ) noexcept
: _M_data ( __inref . _M_data )
{ }

reference_wrapper &
operator = ( const reference_wrapper < _Tp > & __inref ) noexcept
{
_M_data = __inref . _M_data ;
return * this ;
}

operator _Tp & ( ) const noexcept
{ return this -> get ( ) ; }

_Tp &
get ( ) const noexcept
{ return * _M_data ; }

template < typename ... _Args >
typename result_of < _Tp & ( _Args && ... ) > :: type
operator ( ) ( _Args && ... __args ) const
{
return __invoke ( get ( ) , std :: forward < _Args > ( __args ) ... ) ;
}
} ;



template < typename _Tp >
inline reference_wrapper < _Tp >
ref ( _Tp & __t ) noexcept
{ return reference_wrapper < _Tp > ( __t ) ; }


template < typename _Tp >
inline reference_wrapper < const _Tp >
cref ( const _Tp & __t ) noexcept
{ return reference_wrapper < const _Tp > ( __t ) ; }

template < typename _Tp >
void ref ( const _Tp && ) = delete ;

template < typename _Tp >
void cref ( const _Tp && ) = delete ;


template < typename _Tp >
inline reference_wrapper < _Tp >
ref ( reference_wrapper < _Tp > __t ) noexcept
{ return ref ( __t . get ( ) ) ; }


template < typename _Tp >
inline reference_wrapper < const _Tp >
cref ( reference_wrapper < _Tp > __t ) noexcept
{ return cref ( __t . get ( ) ) ; }



template < typename ... _Types >
struct _Pack : integral_constant < size_t , sizeof ... ( _Types ) >
{ } ;

template < typename _From , typename _To , bool = _From :: value == _To :: value >
struct _AllConvertible : false_type
{ } ;

template < typename ... _From , typename ... _To >
struct _AllConvertible < _Pack < _From ... > , _Pack < _To ... > , true >
: __and_ < is_convertible < _From , _To > ... >
{ } ;

template < typename _Tp1 , typename _Tp2 >
using _NotSame = __not_ < is_same < typename std :: decay < _Tp1 > :: type ,
typename std :: decay < _Tp2 > :: type >> ;
#526
template < typename _Res , typename ... _ArgTypes >
struct _Maybe_unary_or_binary_function { } ;


template < typename _Res , typename _T1 >
struct _Maybe_unary_or_binary_function < _Res , _T1 >
: std :: unary_function < _T1 , _Res > { } ;


template < typename _Res , typename _T1 , typename _T2 >
struct _Maybe_unary_or_binary_function < _Res , _T1 , _T2 >
: std :: binary_function < _T1 , _T2 , _Res > { } ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
class _Mem_fn < _Res ( _Class :: * ) ( _ArgTypes ... ) >
: public _Maybe_unary_or_binary_function < _Res , _Class * , _ArgTypes ... >
{
typedef _Res ( _Class :: * _Functor ) ( _ArgTypes ... ) ;

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __object , const volatile _Class * ,
_Args && ... __args ) const
{
return ( std :: forward < _Tp > ( __object ) .* __pmf )
( std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __ptr , const volatile void * , _Args && ... __args ) const
{ return ( ( * __ptr ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }


template < typename ... _Args >
using _RequireValidArgs
= _Require < _AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;



template < typename _Tp , typename ... _Args >
using _RequireValidArgs2
= _Require < _NotSame < _Class , _Tp > , _NotSame < _Class * , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;



template < typename _Tp , typename ... _Args >
using _RequireValidArgs3
= _Require < is_base_of < _Class , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

public :
typedef _Res result_type ;

explicit _Mem_fn ( _Functor __pmf ) : __pmf ( __pmf ) { }


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( _Class & __object , _Args && ... __args ) const
{ return ( __object .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( _Class && __object , _Args && ... __args ) const
{
return ( std :: move ( __object ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ;
}


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( _Class * __object , _Args && ... __args ) const
{ return ( __object ->* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }


template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs2 < _Tp , _Args ... >>
_Res
operator ( ) ( _Tp && __object , _Args && ... __args ) const
{
return _M_call ( std :: forward < _Tp > ( __object ) , & __object ,
std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs3 < _Tp , _Args ... >>
_Res
operator ( ) ( reference_wrapper < _Tp > __ref , _Args && ... __args ) const
{ return operator ( ) ( __ref . get ( ) , std :: forward < _Args > ( __args ) ... ) ; }

private :
_Functor __pmf ;
} ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
class _Mem_fn < _Res ( _Class :: * ) ( _ArgTypes ... ) const >
: public _Maybe_unary_or_binary_function < _Res , const _Class * ,
_ArgTypes ... >
{
typedef _Res ( _Class :: * _Functor ) ( _ArgTypes ... ) const ;

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __object , const volatile _Class * ,
_Args && ... __args ) const
{
return ( std :: forward < _Tp > ( __object ) .* __pmf )
( std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __ptr , const volatile void * , _Args && ... __args ) const
{ return ( ( * __ptr ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename ... _Args >
using _RequireValidArgs
= _Require < _AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

template < typename _Tp , typename ... _Args >
using _RequireValidArgs2
= _Require < _NotSame < _Class , _Tp > , _NotSame < const _Class * , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

template < typename _Tp , typename ... _Args >
using _RequireValidArgs3
= _Require < is_base_of < _Class , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

public :
typedef _Res result_type ;

explicit _Mem_fn ( _Functor __pmf ) : __pmf ( __pmf ) { }


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( const _Class & __object , _Args && ... __args ) const
{ return ( __object .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( const _Class && __object , _Args && ... __args ) const
{
return ( std :: move ( __object ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ;
}


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( const _Class * __object , _Args && ... __args ) const
{ return ( __object ->* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }


template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs2 < _Tp , _Args ... >>
_Res operator ( ) ( _Tp && __object , _Args && ... __args ) const
{
return _M_call ( std :: forward < _Tp > ( __object ) , & __object ,
std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs3 < _Tp , _Args ... >>
_Res
operator ( ) ( reference_wrapper < _Tp > __ref , _Args && ... __args ) const
{ return operator ( ) ( __ref . get ( ) , std :: forward < _Args > ( __args ) ... ) ; }

private :
_Functor __pmf ;
} ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
class _Mem_fn < _Res ( _Class :: * ) ( _ArgTypes ... ) volatile >
: public _Maybe_unary_or_binary_function < _Res , volatile _Class * ,
_ArgTypes ... >
{
typedef _Res ( _Class :: * _Functor ) ( _ArgTypes ... ) volatile ;

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __object , const volatile _Class * ,
_Args && ... __args ) const
{
return ( std :: forward < _Tp > ( __object ) .* __pmf )
( std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __ptr , const volatile void * , _Args && ... __args ) const
{ return ( ( * __ptr ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename ... _Args >
using _RequireValidArgs
= _Require < _AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

template < typename _Tp , typename ... _Args >
using _RequireValidArgs2
= _Require < _NotSame < _Class , _Tp > , _NotSame < volatile _Class * , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

template < typename _Tp , typename ... _Args >
using _RequireValidArgs3
= _Require < is_base_of < _Class , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

public :
typedef _Res result_type ;

explicit _Mem_fn ( _Functor __pmf ) : __pmf ( __pmf ) { }


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( volatile _Class & __object , _Args && ... __args ) const
{ return ( __object .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( volatile _Class && __object , _Args && ... __args ) const
{
return ( std :: move ( __object ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ;
}


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( volatile _Class * __object , _Args && ... __args ) const
{ return ( __object ->* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }


template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs2 < _Tp , _Args ... >>
_Res
operator ( ) ( _Tp && __object , _Args && ... __args ) const
{
return _M_call ( std :: forward < _Tp > ( __object ) , & __object ,
std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs3 < _Tp , _Args ... >>
_Res
operator ( ) ( reference_wrapper < _Tp > __ref , _Args && ... __args ) const
{ return operator ( ) ( __ref . get ( ) , std :: forward < _Args > ( __args ) ... ) ; }

private :
_Functor __pmf ;
} ;


template < typename _Res , typename _Class , typename ... _ArgTypes >
class _Mem_fn < _Res ( _Class :: * ) ( _ArgTypes ... ) const volatile >
: public _Maybe_unary_or_binary_function < _Res , const volatile _Class * ,
_ArgTypes ... >
{
typedef _Res ( _Class :: * _Functor ) ( _ArgTypes ... ) const volatile ;

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __object , const volatile _Class * ,
_Args && ... __args ) const
{
return ( std :: forward < _Tp > ( __object ) .* __pmf )
( std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args >
_Res
_M_call ( _Tp && __ptr , const volatile void * , _Args && ... __args ) const
{ return ( ( * __ptr ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename ... _Args >
using _RequireValidArgs
= _Require < _AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

template < typename _Tp , typename ... _Args >
using _RequireValidArgs2
= _Require < _NotSame < _Class , _Tp > ,
_NotSame < const volatile _Class * , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

template < typename _Tp , typename ... _Args >
using _RequireValidArgs3
= _Require < is_base_of < _Class , _Tp > ,
_AllConvertible < _Pack < _Args ... > , _Pack < _ArgTypes ... >> > ;

public :
typedef _Res result_type ;

explicit _Mem_fn ( _Functor __pmf ) : __pmf ( __pmf ) { }


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( const volatile _Class & __object , _Args && ... __args ) const
{ return ( __object .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }

template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( const volatile _Class && __object , _Args && ... __args ) const
{
return ( std :: move ( __object ) .* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ;
}


template < typename ... _Args , typename _Req = _RequireValidArgs < _Args ... >>
_Res
operator ( ) ( const volatile _Class * __object , _Args && ... __args ) const
{ return ( __object ->* __pmf ) ( std :: forward < _Args > ( __args ) ... ) ; }


template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs2 < _Tp , _Args ... >>
_Res operator ( ) ( _Tp && __object , _Args && ... __args ) const
{
return _M_call ( std :: forward < _Tp > ( __object ) , & __object ,
std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename ... _Args ,
typename _Req = _RequireValidArgs3 < _Tp , _Args ... >>
_Res
operator ( ) ( reference_wrapper < _Tp > __ref , _Args && ... __args ) const
{ return operator ( ) ( __ref . get ( ) , std :: forward < _Args > ( __args ) ... ) ; }

private :
_Functor __pmf ;
} ;


template < typename _Tp , bool >
struct _Mem_fn_const_or_non
{
typedef const _Tp & type ;
} ;

template < typename _Tp >
struct _Mem_fn_const_or_non < _Tp , false >
{
typedef _Tp & type ;
} ;

template < typename _Res , typename _Class >
class _Mem_fn < _Res _Class :: * >
{
using __pm_type = _Res _Class :: * ;




template < typename _Tp >
auto
_M_call ( _Tp && __object , const _Class * ) const noexcept
-> decltype ( std :: forward < _Tp > ( __object ) .* std :: declval < __pm_type & > ( ) )
{ return std :: forward < _Tp > ( __object ) .* __pm ; }

template < typename _Tp , typename _Up >
auto
_M_call ( _Tp && __object , _Up * const * ) const noexcept
-> decltype ( ( * std :: forward < _Tp > ( __object ) ) .* std :: declval < __pm_type & > ( ) )
{ return ( * std :: forward < _Tp > ( __object ) ) .* __pm ; }

template < typename _Tp >
auto
_M_call ( _Tp && __ptr , const volatile void * ) const
noexcept ( noexcept ( ( * __ptr ) .* std :: declval < __pm_type & > ( ) ) )
-> decltype ( ( * __ptr ) .* std :: declval < __pm_type & > ( ) )
{ return ( * __ptr ) .* __pm ; }

public :
explicit
_Mem_fn ( _Res _Class :: * __pm ) noexcept : __pm ( __pm ) { }


_Res &
operator ( ) ( _Class & __object ) const noexcept
{ return __object .* __pm ; }

const _Res &
operator ( ) ( const _Class & __object ) const noexcept
{ return __object .* __pm ; }

_Res &&
operator ( ) ( _Class && __object ) const noexcept
{ return std :: forward < _Class > ( __object ) .* __pm ; }

const _Res &&
operator ( ) ( const _Class && __object ) const noexcept
{ return std :: forward < const _Class > ( __object ) .* __pm ; }


_Res &
operator ( ) ( _Class * __object ) const noexcept
{ return __object ->* __pm ; }

const _Res &
operator ( ) ( const _Class * __object ) const noexcept
{ return __object ->* __pm ; }


template < typename _Tp , typename _Req = _Require < _NotSame < _Class * , _Tp >> >
auto
operator ( ) ( _Tp && __unknown ) const
noexcept ( noexcept ( std :: declval < _Mem_fn * > ( ) -> _M_call
( std :: forward < _Tp > ( __unknown ) , & __unknown ) ) )
-> decltype ( this -> _M_call ( std :: forward < _Tp > ( __unknown ) , & __unknown ) )
{ return _M_call ( std :: forward < _Tp > ( __unknown ) , & __unknown ) ; }

template < typename _Tp , typename _Req = _Require < is_base_of < _Class , _Tp >> >
auto
operator ( ) ( reference_wrapper < _Tp > __ref ) const
noexcept ( noexcept ( std :: declval < _Mem_fn & > ( ) ( __ref . get ( ) ) ) )
-> decltype ( ( * this ) ( __ref . get ( ) ) )
{ return ( * this ) ( __ref . get ( ) ) ; }

private :
_Res _Class :: * __pm ;
} ;
#959
template < typename _Tp , typename _Class >
inline _Mem_fn < _Tp _Class :: * >
mem_fn ( _Tp _Class :: * __pm ) noexcept
{
return _Mem_fn < _Tp _Class :: * > ( __pm ) ;
}
#972
template < typename _Tp >
struct is_bind_expression
: public false_type { } ;
#981
template < typename _Tp >
struct is_placeholder
: public integral_constant < int , 0 >
{ } ;




template < int _Num > struct _Placeholder { } ;
#997
namespace placeholders
{





extern const _Placeholder < 1 > _1 ;
extern const _Placeholder < 2 > _2 ;
extern const _Placeholder < 3 > _3 ;
extern const _Placeholder < 4 > _4 ;
extern const _Placeholder < 5 > _5 ;
extern const _Placeholder < 6 > _6 ;
extern const _Placeholder < 7 > _7 ;
extern const _Placeholder < 8 > _8 ;
extern const _Placeholder < 9 > _9 ;
extern const _Placeholder < 10 > _10 ;
extern const _Placeholder < 11 > _11 ;
extern const _Placeholder < 12 > _12 ;
extern const _Placeholder < 13 > _13 ;
extern const _Placeholder < 14 > _14 ;
extern const _Placeholder < 15 > _15 ;
extern const _Placeholder < 16 > _16 ;
extern const _Placeholder < 17 > _17 ;
extern const _Placeholder < 18 > _18 ;
extern const _Placeholder < 19 > _19 ;
extern const _Placeholder < 20 > _20 ;
extern const _Placeholder < 21 > _21 ;
extern const _Placeholder < 22 > _22 ;
extern const _Placeholder < 23 > _23 ;
extern const _Placeholder < 24 > _24 ;
extern const _Placeholder < 25 > _25 ;
extern const _Placeholder < 26 > _26 ;
extern const _Placeholder < 27 > _27 ;
extern const _Placeholder < 28 > _28 ;
extern const _Placeholder < 29 > _29 ;

}
#1043
template < int _Num >
struct is_placeholder < _Placeholder < _Num > >
: public integral_constant < int , _Num >
{ } ;

template < int _Num >
struct is_placeholder < const _Placeholder < _Num > >
: public integral_constant < int , _Num >
{ } ;





struct _No_tuple_element ;
#1064
template < std :: size_t __i , typename _Tuple , bool _IsSafe >
struct _Safe_tuple_element_impl
: tuple_element < __i , _Tuple > { } ;
#1073
template < std :: size_t __i , typename _Tuple >
struct _Safe_tuple_element_impl < __i , _Tuple , false >
{
typedef _No_tuple_element type ;
} ;





template < std :: size_t __i , typename _Tuple >
struct _Safe_tuple_element
: _Safe_tuple_element_impl < __i , _Tuple ,
( __i < tuple_size < _Tuple > :: value ) >
{ } ;
#1100
template < typename _Arg ,
bool _IsBindExp = is_bind_expression < _Arg > :: value ,
bool _IsPlaceholder = ( is_placeholder < _Arg > :: value > 0 ) >
class _Mu ;





template < typename _Tp >
class _Mu < reference_wrapper < _Tp > , false , false >
{
public :
typedef _Tp & result_type ;





template < typename _CVRef , typename _Tuple >
result_type
operator ( ) ( _CVRef & __arg , _Tuple & ) const volatile
{ return __arg . get ( ) ; }
} ;
#1130
template < typename _Arg >
class _Mu < _Arg , true , false >
{
public :
template < typename _CVArg , typename ... _Args >
auto
operator ( ) ( _CVArg & __arg ,
tuple < _Args ... > & __tuple ) const volatile
-> decltype ( __arg ( declval < _Args > ( ) ... ) )
{

typedef typename _Build_index_tuple < sizeof ... ( _Args ) > :: __type
_Indexes ;
return this -> __call ( __arg , __tuple , _Indexes ( ) ) ;
}

private :


template < typename _CVArg , typename ... _Args , std :: size_t ... _Indexes >
auto
__call ( _CVArg & __arg , tuple < _Args ... > & __tuple ,
const _Index_tuple < _Indexes ... > & ) const volatile
-> decltype ( __arg ( declval < _Args > ( ) ... ) )
{
return __arg ( std :: forward < _Args > ( get < _Indexes > ( __tuple ) ) ... ) ;
}
} ;
#1164
template < typename _Arg >
class _Mu < _Arg , false , true >
{
public :
template < typename _Signature > class result ;

template < typename _CVMu , typename _CVArg , typename _Tuple >
class result < _CVMu ( _CVArg , _Tuple ) >
{



typedef typename _Safe_tuple_element < ( is_placeholder < _Arg > :: value
- 1 ) , _Tuple > :: type
__base_type ;

public :
typedef typename add_rvalue_reference < __base_type > :: type type ;
} ;

template < typename _Tuple >
typename result < _Mu ( _Arg , _Tuple ) > :: type
operator ( ) ( const volatile _Arg & , _Tuple & __tuple ) const volatile
{
return std :: forward < typename result < _Mu ( _Arg , _Tuple ) > :: type > (
:: std :: get < ( is_placeholder < _Arg > :: value - 1 ) > ( __tuple ) ) ;
}
} ;
#1198
template < typename _Arg >
class _Mu < _Arg , false , false >
{
public :
template < typename _Signature > struct result ;

template < typename _CVMu , typename _CVArg , typename _Tuple >
struct result < _CVMu ( _CVArg , _Tuple ) >
{
typedef typename add_lvalue_reference < _CVArg > :: type type ;
} ;


template < typename _CVArg , typename _Tuple >
_CVArg &&
operator ( ) ( _CVArg && __arg , _Tuple & ) const volatile
{ return std :: forward < _CVArg > ( __arg ) ; }
} ;
#1222
template < typename _Tp >
struct _Maybe_wrap_member_pointer
{
typedef _Tp type ;

static const _Tp &
__do_wrap ( const _Tp & __x )
{ return __x ; }

static _Tp &&
__do_wrap ( _Tp && __x )
{ return static_cast < _Tp && > ( __x ) ; }
} ;
#1241
template < typename _Tp , typename _Class >
struct _Maybe_wrap_member_pointer < _Tp _Class :: * >
{
typedef _Mem_fn < _Tp _Class :: * > type ;

static type
__do_wrap ( _Tp _Class :: * __pm )
{ return type ( __pm ) ; }
} ;





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


template < std :: size_t _Ind , typename ... _Tp >
inline auto
__volget ( volatile tuple < _Tp ... > & __tuple )
-> typename tuple_element < _Ind , tuple < _Tp ... >> :: type volatile &
{ return std :: get < _Ind > ( const_cast < tuple < _Tp ... > & > ( __tuple ) ) ; }


template < std :: size_t _Ind , typename ... _Tp >
inline auto
__volget ( const volatile tuple < _Tp ... > & __tuple )
-> typename tuple_element < _Ind , tuple < _Tp ... >> :: type const volatile &
{ return std :: get < _Ind > ( const_cast < const tuple < _Tp ... > & > ( __tuple ) ) ; }


template < typename _Signature >
struct _Bind ;

template < typename _Functor , typename ... _Bound_args >
class _Bind < _Functor ( _Bound_args ... ) >
: public _Weak_result_type < _Functor >
{
typedef _Bind __self_type ;
typedef typename _Build_index_tuple < sizeof ... ( _Bound_args ) > :: __type
_Bound_indexes ;

_Functor _M_f ;
tuple < _Bound_args ... > _M_bound_args ;


template < typename _Result , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > )
{
return _M_f ( _Mu < _Bound_args > ( )
( get < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Result , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call_c ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ) const
{
return _M_f ( _Mu < _Bound_args > ( )
( get < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Result , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call_v ( tuple < _Args ... > && __args ,
_Index_tuple < _Indexes ... > ) volatile
{
return _M_f ( _Mu < _Bound_args > ( )
( __volget < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Result , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call_c_v ( tuple < _Args ... > && __args ,
_Index_tuple < _Indexes ... > ) const volatile
{
return _M_f ( _Mu < _Bound_args > ( )
( __volget < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}

public :
template < typename ... _Args >
explicit _Bind ( const _Functor & __f , _Args && ... __args )
: _M_f ( __f ) , _M_bound_args ( std :: forward < _Args > ( __args ) ... )
{ }

template < typename ... _Args >
explicit _Bind ( _Functor && __f , _Args && ... __args )
: _M_f ( std :: move ( __f ) ) , _M_bound_args ( std :: forward < _Args > ( __args ) ... )
{ }

_Bind ( const _Bind & ) = default ;

_Bind ( _Bind && __b )
: _M_f ( std :: move ( __b . _M_f ) ) , _M_bound_args ( std :: move ( __b . _M_bound_args ) )
{ }


template < typename ... _Args , typename _Result
= decltype ( std :: declval < _Functor > ( ) (
_Mu < _Bound_args > ( ) ( std :: declval < _Bound_args & > ( ) ,
std :: declval < tuple < _Args ... > & > ( ) ) ... ) ) >
_Result
operator ( ) ( _Args && ... __args )
{
return this -> __call < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}


template < typename ... _Args , typename _Result
= decltype ( std :: declval < typename enable_if < ( sizeof ... ( _Args ) >= 0 ) ,
typename add_const < _Functor > :: type > :: type > ( ) (
_Mu < _Bound_args > ( ) ( std :: declval < const _Bound_args & > ( ) ,
std :: declval < tuple < _Args ... > & > ( ) ) ... ) ) >
_Result
operator ( ) ( _Args && ... __args ) const
{
return this -> __call_c < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}


template < typename ... _Args , typename _Result
= decltype ( std :: declval < typename enable_if < ( sizeof ... ( _Args ) >= 0 ) ,
typename add_volatile < _Functor > :: type > :: type > ( ) (
_Mu < _Bound_args > ( ) ( std :: declval < volatile _Bound_args & > ( ) ,
std :: declval < tuple < _Args ... > & > ( ) ) ... ) ) >
_Result
operator ( ) ( _Args && ... __args ) volatile
{
return this -> __call_v < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}


template < typename ... _Args , typename _Result
= decltype ( std :: declval < typename enable_if < ( sizeof ... ( _Args ) >= 0 ) ,
typename add_cv < _Functor > :: type > :: type > ( ) (
_Mu < _Bound_args > ( ) ( std :: declval < const volatile _Bound_args & > ( ) ,
std :: declval < tuple < _Args ... > & > ( ) ) ... ) ) >
_Result
operator ( ) ( _Args && ... __args ) const volatile
{
return this -> __call_c_v < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}
} ;


template < typename _Result , typename _Signature >
struct _Bind_result ;

template < typename _Result , typename _Functor , typename ... _Bound_args >
class _Bind_result < _Result , _Functor ( _Bound_args ... ) >
{
typedef _Bind_result __self_type ;
typedef typename _Build_index_tuple < sizeof ... ( _Bound_args ) > :: __type
_Bound_indexes ;

_Functor _M_f ;
tuple < _Bound_args ... > _M_bound_args ;


template < typename _Res >
struct __enable_if_void : enable_if < is_void < _Res > :: value , int > { } ;
template < typename _Res >
struct __disable_if_void : enable_if < ! is_void < _Res > :: value , int > { } ;


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ,
typename __disable_if_void < _Res > :: type = 0 )
{
return _M_f ( _Mu < _Bound_args > ( )
( get < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
void
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ,
typename __enable_if_void < _Res > :: type = 0 )
{
_M_f ( _Mu < _Bound_args > ( )
( get < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ,
typename __disable_if_void < _Res > :: type = 0 ) const
{
return _M_f ( _Mu < _Bound_args > ( )
( get < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
void
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ,
typename __enable_if_void < _Res > :: type = 0 ) const
{
_M_f ( _Mu < _Bound_args > ( )
( get < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ,
typename __disable_if_void < _Res > :: type = 0 ) volatile
{
return _M_f ( _Mu < _Bound_args > ( )
( __volget < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
void
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ,
typename __enable_if_void < _Res > :: type = 0 ) volatile
{
_M_f ( _Mu < _Bound_args > ( )
( __volget < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
_Result
__call ( tuple < _Args ... > && __args , _Index_tuple < _Indexes ... > ,
typename __disable_if_void < _Res > :: type = 0 ) const volatile
{
return _M_f ( _Mu < _Bound_args > ( )
( __volget < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}


template < typename _Res , typename ... _Args , std :: size_t ... _Indexes >
void
__call ( tuple < _Args ... > && __args ,
_Index_tuple < _Indexes ... > ,
typename __enable_if_void < _Res > :: type = 0 ) const volatile
{
_M_f ( _Mu < _Bound_args > ( )
( __volget < _Indexes > ( _M_bound_args ) , __args ) ... ) ;
}

public :
typedef _Result result_type ;

template < typename ... _Args >
explicit _Bind_result ( const _Functor & __f , _Args && ... __args )
: _M_f ( __f ) , _M_bound_args ( std :: forward < _Args > ( __args ) ... )
{ }

template < typename ... _Args >
explicit _Bind_result ( _Functor && __f , _Args && ... __args )
: _M_f ( std :: move ( __f ) ) , _M_bound_args ( std :: forward < _Args > ( __args ) ... )
{ }

_Bind_result ( const _Bind_result & ) = default ;

_Bind_result ( _Bind_result && __b )
: _M_f ( std :: move ( __b . _M_f ) ) , _M_bound_args ( std :: move ( __b . _M_bound_args ) )
{ }


template < typename ... _Args >
result_type
operator ( ) ( _Args && ... __args )
{
return this -> __call < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}


template < typename ... _Args >
result_type
operator ( ) ( _Args && ... __args ) const
{
return this -> __call < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}


template < typename ... _Args >
result_type
operator ( ) ( _Args && ... __args ) volatile
{
return this -> __call < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}


template < typename ... _Args >
result_type
operator ( ) ( _Args && ... __args ) const volatile
{
return this -> __call < _Result > (
std :: forward_as_tuple ( std :: forward < _Args > ( __args ) ... ) ,
_Bound_indexes ( ) ) ;
}
} ;





template < typename _Signature >
struct is_bind_expression < _Bind < _Signature > >
: public true_type { } ;





template < typename _Signature >
struct is_bind_expression < const _Bind < _Signature > >
: public true_type { } ;





template < typename _Signature >
struct is_bind_expression < volatile _Bind < _Signature > >
: public true_type { } ;





template < typename _Signature >
struct is_bind_expression < const volatile _Bind < _Signature >>
: public true_type { } ;





template < typename _Result , typename _Signature >
struct is_bind_expression < _Bind_result < _Result , _Signature >>
: public true_type { } ;





template < typename _Result , typename _Signature >
struct is_bind_expression < const _Bind_result < _Result , _Signature >>
: public true_type { } ;





template < typename _Result , typename _Signature >
struct is_bind_expression < volatile _Bind_result < _Result , _Signature >>
: public true_type { } ;





template < typename _Result , typename _Signature >
struct is_bind_expression < const volatile _Bind_result < _Result , _Signature >>
: public true_type { } ;




template < typename _Tp , typename _Tp2 = typename decay < _Tp > :: type >
using __is_socketlike = __or_ < is_integral < _Tp2 > , is_enum < _Tp2 >> ;

template < bool _SocketLike , typename _Func , typename ... _BoundArgs >
struct _Bind_helper
{
typedef _Maybe_wrap_member_pointer < typename decay < _Func > :: type >
__maybe_type ;
typedef typename __maybe_type :: type __func_type ;
typedef _Bind < __func_type ( typename decay < _BoundArgs > :: type ... ) > type ;
} ;




template < typename _Func , typename ... _BoundArgs >
struct _Bind_helper < true , _Func , _BoundArgs ... >
{ } ;





template < typename _Func , typename ... _BoundArgs >
inline typename
_Bind_helper < __is_socketlike < _Func > :: value , _Func , _BoundArgs ... > :: type
bind ( _Func && __f , _BoundArgs && ... __args )
{
typedef _Bind_helper < false , _Func , _BoundArgs ... > __helper_type ;
typedef typename __helper_type :: __maybe_type __maybe_type ;
typedef typename __helper_type :: type __result_type ;
return __result_type ( __maybe_type :: __do_wrap ( std :: forward < _Func > ( __f ) ) ,
std :: forward < _BoundArgs > ( __args ) ... ) ;
}

template < typename _Result , typename _Func , typename ... _BoundArgs >
struct _Bindres_helper
{
typedef _Maybe_wrap_member_pointer < typename decay < _Func > :: type >
__maybe_type ;
typedef typename __maybe_type :: type __functor_type ;
typedef _Bind_result < _Result ,
__functor_type ( typename decay < _BoundArgs > :: type ... ) >
type ;
} ;





template < typename _Result , typename _Func , typename ... _BoundArgs >
inline
typename _Bindres_helper < _Result , _Func , _BoundArgs ... > :: type
bind ( _Func && __f , _BoundArgs && ... __args )
{
typedef _Bindres_helper < _Result , _Func , _BoundArgs ... > __helper_type ;
typedef typename __helper_type :: __maybe_type __maybe_type ;
typedef typename __helper_type :: type __result_type ;
return __result_type ( __maybe_type :: __do_wrap ( std :: forward < _Func > ( __f ) ) ,
std :: forward < _BoundArgs > ( __args ) ... ) ;
}

template < typename _Signature >
struct _Bind_simple ;

template < typename _Callable , typename ... _Args >
struct _Bind_simple < _Callable ( _Args ... ) >
{
typedef typename result_of < _Callable ( _Args ... ) > :: type result_type ;

template < typename ... _Args2 , typename = typename
enable_if < sizeof ... ( _Args ) == sizeof ... ( _Args2 ) > :: type >
explicit
_Bind_simple ( const _Callable & __callable , _Args2 && ... __args )
: _M_bound ( __callable , std :: forward < _Args2 > ( __args ) ... )
{ }

template < typename ... _Args2 , typename = typename
enable_if < sizeof ... ( _Args ) == sizeof ... ( _Args2 ) > :: type >
explicit
_Bind_simple ( _Callable && __callable , _Args2 && ... __args )
: _M_bound ( std :: move ( __callable ) , std :: forward < _Args2 > ( __args ) ... )
{ }

_Bind_simple ( const _Bind_simple & ) = default ;
_Bind_simple ( _Bind_simple && ) = default ;

result_type
operator ( ) ( )
{
typedef typename _Build_index_tuple < sizeof ... ( _Args ) > :: __type _Indices ;
return _M_invoke ( _Indices ( ) ) ;
}

private :

template < std :: size_t ... _Indices >
typename result_of < _Callable ( _Args ... ) > :: type
_M_invoke ( _Index_tuple < _Indices ... > )
{


return std :: forward < _Callable > ( std :: get < 0 > ( _M_bound ) ) (
std :: forward < _Args > ( std :: get < _Indices + 1 > ( _M_bound ) ) ... ) ;
}

std :: tuple < _Callable , _Args ... > _M_bound ;
} ;

template < typename _Func , typename ... _BoundArgs >
struct _Bind_simple_helper
{
typedef _Maybe_wrap_member_pointer < typename decay < _Func > :: type >
__maybe_type ;
typedef typename __maybe_type :: type __func_type ;
typedef _Bind_simple < __func_type ( typename decay < _BoundArgs > :: type ... ) >
__type ;
} ;



template < typename _Callable , typename ... _Args >
typename _Bind_simple_helper < _Callable , _Args ... > :: __type
__bind_simple ( _Callable && __callable , _Args && ... __args )
{
typedef _Bind_simple_helper < _Callable , _Args ... > __helper_type ;
typedef typename __helper_type :: __maybe_type __maybe_type ;
typedef typename __helper_type :: __type __result_type ;
return __result_type (
__maybe_type :: __do_wrap ( std :: forward < _Callable > ( __callable ) ) ,
std :: forward < _Args > ( __args ) ... ) ;
}
#1767
class bad_function_call : public std :: exception
{
public :
virtual ~ bad_function_call ( ) noexcept ;

const char * what ( ) const noexcept ;
} ;
#1780
template < typename _Tp >
struct __is_location_invariant
: integral_constant < bool , ( is_pointer < _Tp > :: value
|| is_member_pointer < _Tp > :: value ) >
{ } ;

class _Undefined_class ;

union _Nocopy_types
{
void * _M_object ;
const void * _M_const_object ;
void ( * _M_function_pointer ) ( ) ;
void ( _Undefined_class :: * _M_member_pointer ) ( ) ;
} ;

union _Any_data
{
void * _M_access ( ) { return & _M_pod_data [ 0 ] ; }
const void * _M_access ( ) const { return & _M_pod_data [ 0 ] ; }

template < typename _Tp >
_Tp &
_M_access ( )
{ return * static_cast < _Tp * > ( _M_access ( ) ) ; }

template < typename _Tp >
const _Tp &
_M_access ( ) const
{ return * static_cast < const _Tp * > ( _M_access ( ) ) ; }

_Nocopy_types _M_unused ;
char _M_pod_data [ sizeof ( _Nocopy_types ) ] ;
} ;

enum _Manager_operation
{
__get_type_info ,
__get_functor_ptr ,
__clone_functor ,
__destroy_functor
} ;



template < typename _Tp >
struct _Simple_type_wrapper
{
_Simple_type_wrapper ( _Tp __value ) : __value ( __value ) { }

_Tp __value ;
} ;

template < typename _Tp >
struct __is_location_invariant < _Simple_type_wrapper < _Tp > >
: __is_location_invariant < _Tp >
{ } ;



template < typename _Functor >
inline _Functor &
__callable_functor ( _Functor & __f )
{ return __f ; }

template < typename _Member , typename _Class >
inline _Mem_fn < _Member _Class :: * >
__callable_functor ( _Member _Class :: * & __p )
{ return std :: mem_fn ( __p ) ; }

template < typename _Member , typename _Class >
inline _Mem_fn < _Member _Class :: * >
__callable_functor ( _Member _Class :: * const & __p )
{ return std :: mem_fn ( __p ) ; }

template < typename _Member , typename _Class >
inline _Mem_fn < _Member _Class :: * >
__callable_functor ( _Member _Class :: * volatile & __p )
{ return std :: mem_fn ( __p ) ; }

template < typename _Member , typename _Class >
inline _Mem_fn < _Member _Class :: * >
__callable_functor ( _Member _Class :: * const volatile & __p )
{ return std :: mem_fn ( __p ) ; }

template < typename _Signature >
class function ;


class _Function_base
{
public :
static const std :: size_t _M_max_size = sizeof ( _Nocopy_types ) ;
static const std :: size_t _M_max_align = __alignof ( _Nocopy_types ) ;

template < typename _Functor >
class _Base_manager
{
protected :
static const bool __stored_locally =
( __is_location_invariant < _Functor > :: value
&& sizeof ( _Functor ) <= _M_max_size
&& __alignof ( _Functor ) <= _M_max_align
&& ( _M_max_align % __alignof ( _Functor ) == 0 ) ) ;

typedef integral_constant < bool , __stored_locally > _Local_storage ;


static _Functor *
_M_get_pointer ( const _Any_data & __source )
{
const _Functor * __ptr =
__stored_locally ? std :: __addressof ( __source . _M_access < _Functor > ( ) )
: __source . _M_access < _Functor * > ( ) ;
return const_cast < _Functor * > ( __ptr ) ;
}



static void
_M_clone ( _Any_data & __dest , const _Any_data & __source , true_type )
{
new ( __dest . _M_access ( ) ) _Functor ( __source . _M_access < _Functor > ( ) ) ;
}



static void
_M_clone ( _Any_data & __dest , const _Any_data & __source , false_type )
{
__dest . _M_access < _Functor * > ( ) =
new _Functor ( * __source . _M_access < _Functor * > ( ) ) ;
}



static void
_M_destroy ( _Any_data & __victim , true_type )
{
__victim . _M_access < _Functor > ( ) . ~ _Functor ( ) ;
}


static void
_M_destroy ( _Any_data & __victim , false_type )
{
delete __victim . _M_access < _Functor * > ( ) ;
}

public :
static bool
_M_manager ( _Any_data & __dest , const _Any_data & __source ,
_Manager_operation __op )
{
switch ( __op )
{





case __get_functor_ptr :
__dest . _M_access < _Functor * > ( ) = _M_get_pointer ( __source ) ;
break ;

case __clone_functor :
_M_clone ( __dest , __source , _Local_storage ( ) ) ;
break ;

case __destroy_functor :
_M_destroy ( __dest , _Local_storage ( ) ) ;
break ;
}
return false ;
}

static void
_M_init_functor ( _Any_data & __functor , _Functor && __f )
{ _M_init_functor ( __functor , std :: move ( __f ) , _Local_storage ( ) ) ; }

template < typename _Signature >
static bool
_M_not_empty_function ( const function < _Signature > & __f )
{ return static_cast < bool > ( __f ) ; }

template < typename _Tp >
static bool
_M_not_empty_function ( _Tp * const & __fp )
{ return __fp ; }

template < typename _Class , typename _Tp >
static bool
_M_not_empty_function ( _Tp _Class :: * const & __mp )
{ return __mp ; }

template < typename _Tp >
static bool
_M_not_empty_function ( const _Tp & )
{ return true ; }

private :
static void
_M_init_functor ( _Any_data & __functor , _Functor && __f , true_type )
{ new ( __functor . _M_access ( ) ) _Functor ( std :: move ( __f ) ) ; }

static void
_M_init_functor ( _Any_data & __functor , _Functor && __f , false_type )
{ __functor . _M_access < _Functor * > ( ) = new _Functor ( std :: move ( __f ) ) ; }
} ;

template < typename _Functor >
class _Ref_manager : public _Base_manager < _Functor * >
{
typedef _Function_base :: _Base_manager < _Functor * > _Base ;

public :
static bool
_M_manager ( _Any_data & __dest , const _Any_data & __source ,
_Manager_operation __op )
{
switch ( __op )
{





case __get_functor_ptr :
__dest . _M_access < _Functor * > ( ) = * _Base :: _M_get_pointer ( __source ) ;
return is_const < _Functor > :: value ;
break ;

default :
_Base :: _M_manager ( __dest , __source , __op ) ;
}
return false ;
}

static void
_M_init_functor ( _Any_data & __functor , reference_wrapper < _Functor > __f )
{
_Base :: _M_init_functor ( __functor , std :: __addressof ( __f . get ( ) ) ) ;
}
} ;

_Function_base ( ) : _M_manager ( 0 ) { }

~ _Function_base ( )
{
if ( _M_manager )
_M_manager ( _M_functor , _M_functor , __destroy_functor ) ;
}


bool _M_empty ( ) const { return ! _M_manager ; }

typedef bool ( * _Manager_type ) ( _Any_data & , const _Any_data & ,
_Manager_operation ) ;

_Any_data _M_functor ;
_Manager_type _M_manager ;
} ;

template < typename _Signature , typename _Functor >
class _Function_handler ;

template < typename _Res , typename _Functor , typename ... _ArgTypes >
class _Function_handler < _Res ( _ArgTypes ... ) , _Functor >
: public _Function_base :: _Base_manager < _Functor >
{
typedef _Function_base :: _Base_manager < _Functor > _Base ;

public :
static _Res
_M_invoke ( const _Any_data & __functor , _ArgTypes ... __args )
{
return ( * _Base :: _M_get_pointer ( __functor ) ) (
std :: forward < _ArgTypes > ( __args ) ... ) ;
}
} ;

template < typename _Functor , typename ... _ArgTypes >
class _Function_handler < void ( _ArgTypes ... ) , _Functor >
: public _Function_base :: _Base_manager < _Functor >
{
typedef _Function_base :: _Base_manager < _Functor > _Base ;

public :
static void
_M_invoke ( const _Any_data & __functor , _ArgTypes ... __args )
{
( * _Base :: _M_get_pointer ( __functor ) ) (
std :: forward < _ArgTypes > ( __args ) ... ) ;
}
} ;

template < typename _Res , typename _Functor , typename ... _ArgTypes >
class _Function_handler < _Res ( _ArgTypes ... ) , reference_wrapper < _Functor > >
: public _Function_base :: _Ref_manager < _Functor >
{
typedef _Function_base :: _Ref_manager < _Functor > _Base ;

public :
static _Res
_M_invoke ( const _Any_data & __functor , _ArgTypes ... __args )
{
return __callable_functor ( * * _Base :: _M_get_pointer ( __functor ) ) (
std :: forward < _ArgTypes > ( __args ) ... ) ;
}
} ;

template < typename _Functor , typename ... _ArgTypes >
class _Function_handler < void ( _ArgTypes ... ) , reference_wrapper < _Functor > >
: public _Function_base :: _Ref_manager < _Functor >
{
typedef _Function_base :: _Ref_manager < _Functor > _Base ;

public :
static void
_M_invoke ( const _Any_data & __functor , _ArgTypes ... __args )
{
__callable_functor ( * * _Base :: _M_get_pointer ( __functor ) ) (
std :: forward < _ArgTypes > ( __args ) ... ) ;
}
} ;

template < typename _Class , typename _Member , typename _Res ,
typename ... _ArgTypes >
class _Function_handler < _Res ( _ArgTypes ... ) , _Member _Class :: * >
: public _Function_handler < void ( _ArgTypes ... ) , _Member _Class :: * >
{
typedef _Function_handler < void ( _ArgTypes ... ) , _Member _Class :: * >
_Base ;

public :
static _Res
_M_invoke ( const _Any_data & __functor , _ArgTypes ... __args )
{
return std :: mem_fn ( _Base :: _M_get_pointer ( __functor ) -> __value ) (
std :: forward < _ArgTypes > ( __args ) ... ) ;
}
} ;

template < typename _Class , typename _Member , typename ... _ArgTypes >
class _Function_handler < void ( _ArgTypes ... ) , _Member _Class :: * >
: public _Function_base :: _Base_manager <
_Simple_type_wrapper < _Member _Class :: * > >
{
typedef _Member _Class :: * _Functor ;
typedef _Simple_type_wrapper < _Functor > _Wrapper ;
typedef _Function_base :: _Base_manager < _Wrapper > _Base ;

public :
static bool
_M_manager ( _Any_data & __dest , const _Any_data & __source ,
_Manager_operation __op )
{
switch ( __op )
{





case __get_functor_ptr :
__dest . _M_access < _Functor * > ( ) =
& _Base :: _M_get_pointer ( __source ) -> __value ;
break ;

default :
_Base :: _M_manager ( __dest , __source , __op ) ;
}
return false ;
}

static void
_M_invoke ( const _Any_data & __functor , _ArgTypes ... __args )
{
std :: mem_fn ( _Base :: _M_get_pointer ( __functor ) -> __value ) (
std :: forward < _ArgTypes > ( __args ) ... ) ;
}
} ;

template < typename _From , typename _To >
using __check_func_return_type
= __or_ < is_void < _To > , is_convertible < _From , _To >> ;
#2173
template < typename _Res , typename ... _ArgTypes >
class function < _Res ( _ArgTypes ... ) >
: public _Maybe_unary_or_binary_function < _Res , _ArgTypes ... > ,
private _Function_base
{
typedef _Res _Signature_type ( _ArgTypes ... ) ;

template < typename _Functor >
using _Invoke = decltype ( __callable_functor ( std :: declval < _Functor & > ( ) )
( std :: declval < _ArgTypes > ( ) ... ) ) ;

template < typename _Functor >
using _Callable = __check_func_return_type < _Invoke < _Functor > , _Res > ;

template < typename _Cond , typename _Tp >
using _Requires = typename enable_if < _Cond :: value , _Tp > :: type ;

public :
typedef _Res result_type ;
#2199
function ( ) noexcept
: _Function_base ( ) { }





function ( nullptr_t ) noexcept
: _Function_base ( ) { }
#2217
function ( const function & __x ) ;
#2226
function ( function && __x ) : _Function_base ( )
{
__x . swap ( * this ) ;
}
#2249
template < typename _Functor ,
typename = _Requires < _Callable < _Functor > , void >>
function ( _Functor ) ;
#2265
function &
operator = ( const function & __x )
{
function ( __x ) . swap ( * this ) ;
return * this ;
}
#2283
function &
operator = ( function && __x )
{
function ( std :: move ( __x ) ) . swap ( * this ) ;
return * this ;
}
#2297
function &
operator = ( nullptr_t )
{
if ( _M_manager )
{
_M_manager ( _M_functor , _M_functor , __destroy_functor ) ;
_M_manager = 0 ;
_M_invoker = 0 ;
}
return * this ;
}
#2325
template < typename _Functor >
_Requires < _Callable < _Functor > , function & >
operator = ( _Functor && __f )
{
function ( std :: forward < _Functor > ( __f ) ) . swap ( * this ) ;
return * this ;
}


template < typename _Functor >
function &
operator = ( reference_wrapper < _Functor > __f ) noexcept
{
function ( __f ) . swap ( * this ) ;
return * this ;
}
#2351
void swap ( function & __x )
{
std :: swap ( _M_functor , __x . _M_functor ) ;
std :: swap ( _M_manager , __x . _M_manager ) ;
std :: swap ( _M_invoker , __x . _M_invoker ) ;
}
#2379
explicit operator bool ( ) const noexcept
{ return ! _M_empty ( ) ; }
#2392
_Res operator ( ) ( _ArgTypes ... __args ) const ;
#2422
private :
typedef _Res ( * _Invoker_type ) ( const _Any_data & , _ArgTypes ... ) ;
_Invoker_type _M_invoker ;
} ;


template < typename _Res , typename ... _ArgTypes >
function < _Res ( _ArgTypes ... ) > ::
function ( const function & __x )
: _Function_base ( )
{
if ( static_cast < bool > ( __x ) )
{
_M_invoker = __x . _M_invoker ;
_M_manager = __x . _M_manager ;
__x . _M_manager ( _M_functor , __x . _M_functor , __clone_functor ) ;
}
}

template < typename _Res , typename ... _ArgTypes >
template < typename _Functor , typename >
function < _Res ( _ArgTypes ... ) > ::
function ( _Functor __f )
: _Function_base ( )
{
typedef _Function_handler < _Signature_type , _Functor > _My_handler ;

if ( _My_handler :: _M_not_empty_function ( __f ) )
{
_My_handler :: _M_init_functor ( _M_functor , std :: move ( __f ) ) ;
_M_invoker = & _My_handler :: _M_invoke ;
_M_manager = & _My_handler :: _M_manager ;
}
}

template < typename _Res , typename ... _ArgTypes >
_Res
function < _Res ( _ArgTypes ... ) > ::
operator ( ) ( _ArgTypes ... __args ) const
{
if ( _M_empty ( ) )
__throw_bad_function_call ( ) ;
return _M_invoker ( _M_functor , std :: forward < _ArgTypes > ( __args ) ... ) ;
}
#2528
template < typename _Res , typename ... _Args >
inline bool
operator == ( const function < _Res ( _Args ... ) > & __f , nullptr_t ) noexcept
{ return ! static_cast < bool > ( __f ) ; }


template < typename _Res , typename ... _Args >
inline bool
operator == ( nullptr_t , const function < _Res ( _Args ... ) > & __f ) noexcept
{ return ! static_cast < bool > ( __f ) ; }
#2546
template < typename _Res , typename ... _Args >
inline bool
operator != ( const function < _Res ( _Args ... ) > & __f , nullptr_t ) noexcept
{ return static_cast < bool > ( __f ) ; }


template < typename _Res , typename ... _Args >
inline bool
operator != ( nullptr_t , const function < _Res ( _Args ... ) > & __f ) noexcept
{ return static_cast < bool > ( __f ) ; }
#2564
template < typename _Res , typename ... _Args >
inline void
swap ( function < _Res ( _Args ... ) > & __x , function < _Res ( _Args ... ) > & __y )
{ __x . swap ( __y ) ; }


}
#71 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_algo.h"
namespace std
{



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




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


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





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




template < typename _InputIterator , typename _Tp >
inline _InputIterator
__find ( _InputIterator __first , _InputIterator __last ,
const _Tp & __val , input_iterator_tag )
{
while ( __first != __last && ! ( * __first == __val ) )
++ __first ;
return __first ;
}


template < typename _InputIterator , typename _Predicate >
inline _InputIterator
__find_if ( _InputIterator __first , _InputIterator __last ,
_Predicate __pred , input_iterator_tag )
{
while ( __first != __last && ! bool ( __pred ( * __first ) ) )
++ __first ;
return __first ;
}


template < typename _RandomAccessIterator , typename _Tp >
_RandomAccessIterator
__find ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
const _Tp & __val , random_access_iterator_tag )
{
typename iterator_traits < _RandomAccessIterator > :: difference_type
__trip_count = ( __last - __first ) >> 2 ;

for ( ; __trip_count > 0 ; -- __trip_count )
{
if ( * __first == __val )
return __first ;
++ __first ;

if ( * __first == __val )
return __first ;
++ __first ;

if ( * __first == __val )
return __first ;
++ __first ;

if ( * __first == __val )
return __first ;
++ __first ;
}

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


template < typename _RandomAccessIterator , typename _Predicate >
_RandomAccessIterator
__find_if ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Predicate __pred , random_access_iterator_tag )
{
typename iterator_traits < _RandomAccessIterator > :: difference_type
__trip_count = ( __last - __first ) >> 2 ;

for ( ; __trip_count > 0 ; -- __trip_count )
{
if ( __pred ( * __first ) )
return __first ;
++ __first ;

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

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

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

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


template < typename _InputIterator , typename _Predicate >
inline _InputIterator
__find_if_not ( _InputIterator __first , _InputIterator __last ,
_Predicate __pred , input_iterator_tag )
{
while ( __first != __last && bool ( __pred ( * __first ) ) )
++ __first ;
return __first ;
}


template < typename _RandomAccessIterator , typename _Predicate >
_RandomAccessIterator
__find_if_not ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Predicate __pred , random_access_iterator_tag )
{
typename iterator_traits < _RandomAccessIterator > :: difference_type
__trip_count = ( __last - __first ) >> 2 ;

for ( ; __trip_count > 0 ; -- __trip_count )
{
if ( ! bool ( __pred ( * __first ) ) )
return __first ;
++ __first ;

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

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

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

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


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




template < typename _InputIterator , typename _Predicate , typename _Distance >
_InputIterator
__find_if_not_n ( _InputIterator __first , _Distance & __len , _Predicate __pred )
{
for ( ; __len ; -- __len , ++ __first )
if ( ! bool ( __pred ( * __first ) ) )
break ;
return __first ;
}
#351
template < typename _ForwardIterator , typename _Integer , typename _Tp >
_ForwardIterator
__search_n ( _ForwardIterator __first , _ForwardIterator __last ,
_Integer __count , const _Tp & __val ,
std :: forward_iterator_tag )
{
__first = std :: find ( __first , __last , __val ) ;
while ( __first != __last )
{
typename iterator_traits < _ForwardIterator > :: difference_type
__n = __count ;
_ForwardIterator __i = __first ;
++ __i ;
while ( __i != __last && __n != 1 && * __i == __val )
{
++ __i ;
-- __n ;
}
if ( __n == 1 )
return __first ;
if ( __i == __last )
return __last ;
__first = std :: find ( ++ __i , __last , __val ) ;
}
return __last ;
}
#383
template < typename _RandomAccessIter , typename _Integer , typename _Tp >
_RandomAccessIter
__search_n ( _RandomAccessIter __first , _RandomAccessIter __last ,
_Integer __count , const _Tp & __val ,
std :: random_access_iterator_tag )
{

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

_DistanceType __tailSize = __last - __first ;
_DistanceType __remainder = __count ;

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


_RandomAccessIter __backTrack = __first ;
while ( * -- __backTrack == __val )
{
if ( -- __remainder == 0 )
return ( __first - __count ) ;
}
__remainder = __count + 1 - ( __first - __backTrack ) ;
}
return __last ;
}
#421
template < typename _ForwardIterator , typename _Integer , typename _Tp ,
typename _BinaryPredicate >
_ForwardIterator
__search_n ( _ForwardIterator __first , _ForwardIterator __last ,
_Integer __count , const _Tp & __val ,
_BinaryPredicate __binary_pred , std :: forward_iterator_tag )
{
while ( __first != __last && ! bool ( __binary_pred ( * __first , __val ) ) )
++ __first ;

while ( __first != __last )
{
typename iterator_traits < _ForwardIterator > :: difference_type
__n = __count ;
_ForwardIterator __i = __first ;
++ __i ;
while ( __i != __last && __n != 1 && bool ( __binary_pred ( * __i , __val ) ) )
{
++ __i ;
-- __n ;
}
if ( __n == 1 )
return __first ;
if ( __i == __last )
return __last ;
__first = ++ __i ;
while ( __first != __last
&& ! bool ( __binary_pred ( * __first , __val ) ) )
++ __first ;
}
return __last ;
}
#460
template < typename _RandomAccessIter , typename _Integer , typename _Tp ,
typename _BinaryPredicate >
_RandomAccessIter
__search_n ( _RandomAccessIter __first , _RandomAccessIter __last ,
_Integer __count , const _Tp & __val ,
_BinaryPredicate __binary_pred , std :: random_access_iterator_tag )
{

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

_DistanceType __tailSize = __last - __first ;
_DistanceType __remainder = __count ;

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


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


template < typename _ForwardIterator1 , typename _ForwardIterator2 >
_ForwardIterator1
__find_end ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 , _ForwardIterator2 __last2 ,
forward_iterator_tag , forward_iterator_tag )
{
if ( __first2 == __last2 )
return __last1 ;
else
{
_ForwardIterator1 __result = __last1 ;
while ( 1 )
{
_ForwardIterator1 __new_result
= std :: search ( __first1 , __last1 , __first2 , __last2 ) ;
if ( __new_result == __last1 )
return __result ;
else
{
__result = __new_result ;
__first1 = __new_result ;
++ __first1 ;
}
}
}
}

template < typename _ForwardIterator1 , typename _ForwardIterator2 ,
typename _BinaryPredicate >
_ForwardIterator1
__find_end ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 , _ForwardIterator2 __last2 ,
forward_iterator_tag , forward_iterator_tag ,
_BinaryPredicate __comp )
{
if ( __first2 == __last2 )
return __last1 ;
else
{
_ForwardIterator1 __result = __last1 ;
while ( 1 )
{
_ForwardIterator1 __new_result
= std :: search ( __first1 , __last1 , __first2 ,
__last2 , __comp ) ;
if ( __new_result == __last1 )
return __result ;
else
{
__result = __new_result ;
__first1 = __new_result ;
++ __first1 ;
}
}
}
}


template < typename _BidirectionalIterator1 , typename _BidirectionalIterator2 >
_BidirectionalIterator1
__find_end ( _BidirectionalIterator1 __first1 ,
_BidirectionalIterator1 __last1 ,
_BidirectionalIterator2 __first2 ,
_BidirectionalIterator2 __last2 ,
bidirectional_iterator_tag , bidirectional_iterator_tag )
{
#564
typedef reverse_iterator < _BidirectionalIterator1 > _RevIterator1 ;
typedef reverse_iterator < _BidirectionalIterator2 > _RevIterator2 ;

_RevIterator1 __rlast1 ( __first1 ) ;
_RevIterator2 __rlast2 ( __first2 ) ;
_RevIterator1 __rresult = std :: search ( _RevIterator1 ( __last1 ) ,
__rlast1 ,
_RevIterator2 ( __last2 ) ,
__rlast2 ) ;

if ( __rresult == __rlast1 )
return __last1 ;
else
{
_BidirectionalIterator1 __result = __rresult . base ( ) ;
std :: advance ( __result , - std :: distance ( __first2 , __last2 ) ) ;
return __result ;
}
}

template < typename _BidirectionalIterator1 , typename _BidirectionalIterator2 ,
typename _BinaryPredicate >
_BidirectionalIterator1
__find_end ( _BidirectionalIterator1 __first1 ,
_BidirectionalIterator1 __last1 ,
_BidirectionalIterator2 __first2 ,
_BidirectionalIterator2 __last2 ,
bidirectional_iterator_tag , bidirectional_iterator_tag ,
_BinaryPredicate __comp )
{
#600
typedef reverse_iterator < _BidirectionalIterator1 > _RevIterator1 ;
typedef reverse_iterator < _BidirectionalIterator2 > _RevIterator2 ;

_RevIterator1 __rlast1 ( __first1 ) ;
_RevIterator2 __rlast2 ( __first2 ) ;
_RevIterator1 __rresult = std :: search ( _RevIterator1 ( __last1 ) , __rlast1 ,
_RevIterator2 ( __last2 ) , __rlast2 ,
__comp ) ;

if ( __rresult == __rlast1 )
return __last1 ;
else
{
_BidirectionalIterator1 __result = __rresult . base ( ) ;
std :: advance ( __result , - std :: distance ( __first2 , __last2 ) ) ;
return __result ;
}
}
#645
template < typename _ForwardIterator1 , typename _ForwardIterator2 >
inline _ForwardIterator1
find_end ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 , _ForwardIterator2 __last2 )
{
#656
;
;

return std :: __find_end ( __first1 , __last1 , __first2 , __last2 ,
std :: __iterator_category ( __first1 ) ,
std :: __iterator_category ( __first2 ) ) ;
}
#692
template < typename _ForwardIterator1 , typename _ForwardIterator2 ,
typename _BinaryPredicate >
inline _ForwardIterator1
find_end ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 , _ForwardIterator2 __last2 ,
_BinaryPredicate __comp )
{
#705
;
;

return std :: __find_end ( __first1 , __last1 , __first2 , __last2 ,
std :: __iterator_category ( __first1 ) ,
std :: __iterator_category ( __first2 ) ,
__comp ) ;
}
#727
template < typename _InputIterator , typename _Predicate >
inline bool
all_of ( _InputIterator __first , _InputIterator __last , _Predicate __pred )
{ return __last == std :: find_if_not ( __first , __last , __pred ) ; }
#744
template < typename _InputIterator , typename _Predicate >
inline bool
none_of ( _InputIterator __first , _InputIterator __last , _Predicate __pred )
{ return __last == std :: find_if ( __first , __last , __pred ) ; }
#762
template < typename _InputIterator , typename _Predicate >
inline bool
any_of ( _InputIterator __first , _InputIterator __last , _Predicate __pred )
{ return ! std :: none_of ( __first , __last , __pred ) ; }
#777
template < typename _InputIterator , typename _Predicate >
inline _InputIterator
find_if_not ( _InputIterator __first , _InputIterator __last ,
_Predicate __pred )
{




;
return std :: __find_if_not ( __first , __last , __pred ) ;
}
#800
template < typename _InputIterator , typename _Predicate >
inline bool
is_partitioned ( _InputIterator __first , _InputIterator __last ,
_Predicate __pred )
{
__first = std :: find_if_not ( __first , __last , __pred ) ;
return std :: none_of ( __first , __last , __pred ) ;
}
#818
template < typename _ForwardIterator , typename _Predicate >
_ForwardIterator
partition_point ( _ForwardIterator __first , _ForwardIterator __last ,
_Predicate __pred )
{
#829
;

typedef typename iterator_traits < _ForwardIterator > :: difference_type
_DistanceType ;

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

while ( __len > 0 )
{
__half = __len >> 1 ;
__middle = __first ;
std :: advance ( __middle , __half ) ;
if ( __pred ( * __middle ) )
{
__first = __middle ;
++ __first ;
__len = __len - __half - 1 ;
}
else
__len = __half ;
}
return __first ;
}
#871
template < typename _InputIterator , typename _OutputIterator , typename _Tp >
_OutputIterator
remove_copy ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result , const _Tp & __value )
{
#882
;

for ( ; __first != __last ; ++ __first )
if ( ! ( * __first == __value ) )
{
* __result = * __first ;
++ __result ;
}
return __result ;
}
#908
template < typename _InputIterator , typename _OutputIterator ,
typename _Predicate >
_OutputIterator
remove_copy_if ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result , _Predicate __pred )
{
#920
;

for ( ; __first != __last ; ++ __first )
if ( ! bool ( __pred ( * __first ) ) )
{
* __result = * __first ;
++ __result ;
}
return __result ;
}
#947
template < typename _InputIterator , typename _OutputIterator ,
typename _Predicate >
_OutputIterator
copy_if ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result , _Predicate __pred )
{
#959
;

for ( ; __first != __last ; ++ __first )
if ( __pred ( * __first ) )
{
* __result = * __first ;
++ __result ;
}
return __result ;
}


template < typename _InputIterator , typename _Size , typename _OutputIterator >
_OutputIterator
__copy_n ( _InputIterator __first , _Size __n ,
_OutputIterator __result , input_iterator_tag )
{
if ( __n > 0 )
{
while ( true )
{
* __result = * __first ;
++ __result ;
if ( -- __n > 0 )
++ __first ;
else
break ;
}
}
return __result ;
}

template < typename _RandomAccessIterator , typename _Size ,
typename _OutputIterator >
inline _OutputIterator
__copy_n ( _RandomAccessIterator __first , _Size __n ,
_OutputIterator __result , random_access_iterator_tag )
{ return std :: copy ( __first , __first + __n , __result ) ; }
#1011
template < typename _InputIterator , typename _Size , typename _OutputIterator >
inline _OutputIterator
copy_n ( _InputIterator __first , _Size __n , _OutputIterator __result )
{





return std :: __copy_n ( __first , __n , __result ,
std :: __iterator_category ( __first ) ) ;
}
#1039
template < typename _InputIterator , typename _OutputIterator1 ,
typename _OutputIterator2 , typename _Predicate >
pair < _OutputIterator1 , _OutputIterator2 >
partition_copy ( _InputIterator __first , _InputIterator __last ,
_OutputIterator1 __out_true , _OutputIterator2 __out_false ,
_Predicate __pred )
{
#1054
;

for ( ; __first != __last ; ++ __first )
if ( __pred ( * __first ) )
{
* __out_true = * __first ;
++ __out_true ;
}
else
{
* __out_false = * __first ;
++ __out_false ;
}

return pair < _OutputIterator1 , _OutputIterator2 > ( __out_true , __out_false ) ;
}
#1089
template < typename _ForwardIterator , typename _Tp >
_ForwardIterator
remove ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __value )
{





;

__first = std :: find ( __first , __last , __value ) ;
if ( __first == __last )
return __first ;
_ForwardIterator __result = __first ;
++ __first ;
for ( ; __first != __last ; ++ __first )
if ( ! ( * __first == __value ) )
{
* __result = std :: move ( * __first ) ;
++ __result ;
}
return __result ;
}
#1132
template < typename _ForwardIterator , typename _Predicate >
_ForwardIterator
remove_if ( _ForwardIterator __first , _ForwardIterator __last ,
_Predicate __pred )
{





;

__first = std :: find_if ( __first , __last , __pred ) ;
if ( __first == __last )
return __first ;
_ForwardIterator __result = __first ;
++ __first ;
for ( ; __first != __last ; ++ __first )
if ( ! bool ( __pred ( * __first ) ) )
{
* __result = std :: move ( * __first ) ;
++ __result ;
}
return __result ;
}
#1172
template < typename _ForwardIterator >
_ForwardIterator
unique ( _ForwardIterator __first , _ForwardIterator __last )
{





;


__first = std :: adjacent_find ( __first , __last ) ;
if ( __first == __last )
return __last ;


_ForwardIterator __dest = __first ;
++ __first ;
while ( ++ __first != __last )
if ( ! ( * __dest == * __first ) )
* ++ __dest = std :: move ( * __first ) ;
return ++ __dest ;
}
#1212
template < typename _ForwardIterator , typename _BinaryPredicate >
_ForwardIterator
unique ( _ForwardIterator __first , _ForwardIterator __last ,
_BinaryPredicate __binary_pred )
{
#1223
;


__first = std :: adjacent_find ( __first , __last , __binary_pred ) ;
if ( __first == __last )
return __last ;


_ForwardIterator __dest = __first ;
++ __first ;
while ( ++ __first != __last )
if ( ! bool ( __binary_pred ( * __dest , * __first ) ) )
* ++ __dest = std :: move ( * __first ) ;
return ++ __dest ;
}
#1244
template < typename _ForwardIterator , typename _OutputIterator >
_OutputIterator
__unique_copy ( _ForwardIterator __first , _ForwardIterator __last ,
_OutputIterator __result ,
forward_iterator_tag , output_iterator_tag )
{

_ForwardIterator __next = __first ;
* __result = * __first ;
while ( ++ __next != __last )
if ( ! ( * __first == * __next ) )
{
__first = __next ;
* ++ __result = * __first ;
}
return ++ __result ;
}
#1267
template < typename _InputIterator , typename _OutputIterator >
_OutputIterator
__unique_copy ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result ,
input_iterator_tag , output_iterator_tag )
{

typename iterator_traits < _InputIterator > :: value_type __value = * __first ;
* __result = __value ;
while ( ++ __first != __last )
if ( ! ( __value == * __first ) )
{
__value = * __first ;
* ++ __result = __value ;
}
return ++ __result ;
}
#1290
template < typename _InputIterator , typename _ForwardIterator >
_ForwardIterator
__unique_copy ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result ,
input_iterator_tag , forward_iterator_tag )
{

* __result = * __first ;
while ( ++ __first != __last )
if ( ! ( * __result == * __first ) )
* ++ __result = * __first ;
return ++ __result ;
}
#1310
template < typename _ForwardIterator , typename _OutputIterator ,
typename _BinaryPredicate >
_OutputIterator
__unique_copy ( _ForwardIterator __first , _ForwardIterator __last ,
_OutputIterator __result , _BinaryPredicate __binary_pred ,
forward_iterator_tag , output_iterator_tag )
{





_ForwardIterator __next = __first ;
* __result = * __first ;
while ( ++ __next != __last )
if ( ! bool ( __binary_pred ( * __first , * __next ) ) )
{
__first = __next ;
* ++ __result = * __first ;
}
return ++ __result ;
}
#1339
template < typename _InputIterator , typename _OutputIterator ,
typename _BinaryPredicate >
_OutputIterator
__unique_copy ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result , _BinaryPredicate __binary_pred ,
input_iterator_tag , output_iterator_tag )
{





typename iterator_traits < _InputIterator > :: value_type __value = * __first ;
* __result = __value ;
while ( ++ __first != __last )
if ( ! bool ( __binary_pred ( __value , * __first ) ) )
{
__value = * __first ;
* ++ __result = __value ;
}
return ++ __result ;
}
#1368
template < typename _InputIterator , typename _ForwardIterator ,
typename _BinaryPredicate >
_ForwardIterator
__unique_copy ( _InputIterator __first , _InputIterator __last ,
_ForwardIterator __result , _BinaryPredicate __binary_pred ,
input_iterator_tag , forward_iterator_tag )
{





* __result = * __first ;
while ( ++ __first != __last )
if ( ! bool ( __binary_pred ( * __result , * __first ) ) )
* ++ __result = * __first ;
return ++ __result ;
}
#1392
template < typename _BidirectionalIterator >
void
__reverse ( _BidirectionalIterator __first , _BidirectionalIterator __last ,
bidirectional_iterator_tag )
{
while ( true )
if ( __first == __last || __first == -- __last )
return ;
else
{
std :: iter_swap ( __first , __last ) ;
++ __first ;
}
}
#1412
template < typename _RandomAccessIterator >
void
__reverse ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
random_access_iterator_tag )
{
if ( __first == __last )
return ;
-- __last ;
while ( __first < __last )
{
std :: iter_swap ( __first , __last ) ;
++ __first ;
-- __last ;
}
}
#1440
template < typename _BidirectionalIterator >
inline void
reverse ( _BidirectionalIterator __first , _BidirectionalIterator __last )
{



;
std :: __reverse ( __first , __last , std :: __iterator_category ( __first ) ) ;
}
#1467
template < typename _BidirectionalIterator , typename _OutputIterator >
_OutputIterator
reverse_copy ( _BidirectionalIterator __first , _BidirectionalIterator __last ,
_OutputIterator __result )
{





;

while ( __first != __last )
{
-- __last ;
* __result = * __last ;
++ __result ;
}
return __result ;
}





template < typename _EuclideanRingElement >
_EuclideanRingElement
__gcd ( _EuclideanRingElement __m , _EuclideanRingElement __n )
{
while ( __n != 0 )
{
_EuclideanRingElement __t = __m % __n ;
__m = __n ;
__n = __t ;
}
return __m ;
}


template < typename _ForwardIterator >
void
__rotate ( _ForwardIterator __first ,
_ForwardIterator __middle ,
_ForwardIterator __last ,
forward_iterator_tag )
{
if ( __first == __middle || __last == __middle )
return ;

_ForwardIterator __first2 = __middle ;
do
{
std :: iter_swap ( __first , __first2 ) ;
++ __first ;
++ __first2 ;
if ( __first == __middle )
__middle = __first2 ;
}
while ( __first2 != __last ) ;

__first2 = __middle ;

while ( __first2 != __last )
{
std :: iter_swap ( __first , __first2 ) ;
++ __first ;
++ __first2 ;
if ( __first == __middle )
__middle = __first2 ;
else if ( __first2 == __last )
__first2 = __middle ;
}
}


template < typename _BidirectionalIterator >
void
__rotate ( _BidirectionalIterator __first ,
_BidirectionalIterator __middle ,
_BidirectionalIterator __last ,
bidirectional_iterator_tag )
{




if ( __first == __middle || __last == __middle )
return ;

std :: __reverse ( __first , __middle , bidirectional_iterator_tag ( ) ) ;
std :: __reverse ( __middle , __last , bidirectional_iterator_tag ( ) ) ;

while ( __first != __middle && __middle != __last )
{
std :: iter_swap ( __first , -- __last ) ;
++ __first ;
}

if ( __first == __middle )
std :: __reverse ( __middle , __last , bidirectional_iterator_tag ( ) ) ;
else
std :: __reverse ( __first , __middle , bidirectional_iterator_tag ( ) ) ;
}


template < typename _RandomAccessIterator >
void
__rotate ( _RandomAccessIterator __first ,
_RandomAccessIterator __middle ,
_RandomAccessIterator __last ,
random_access_iterator_tag )
{




if ( __first == __middle || __last == __middle )
return ;

typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_Distance ;
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;

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

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

_RandomAccessIterator __p = __first ;

for ( ; ; )
{
if ( __k < __n - __k )
{
if ( __oracle_is_pod ( _ValueType ) && __k == 1 )
{
_ValueType __t = std :: move ( * __p ) ;
std :: move ( __p + 1 , __p + __n , __p ) ;
* ( __p + __n - 1 ) = std :: move ( __t ) ;
return ;
}
_RandomAccessIterator __q = __p + __k ;
for ( _Distance __i = 0 ; __i < __n - __k ; ++ __i )
{
std :: iter_swap ( __p , __q ) ;
++ __p ;
++ __q ;
}
__n %= __k ;
if ( __n == 0 )
return ;
std :: swap ( __n , __k ) ;
__k = __n - __k ;
}
else
{
__k = __n - __k ;
if ( __oracle_is_pod ( _ValueType ) && __k == 1 )
{
_ValueType __t = std :: move ( * ( __p + __n - 1 ) ) ;
std :: move_backward ( __p , __p + __n - 1 , __p + __n ) ;
* __p = std :: move ( __t ) ;
return ;
}
_RandomAccessIterator __q = __p + __n ;
__p = __q - __k ;
for ( _Distance __i = 0 ; __i < __n - __k ; ++ __i )
{
-- __p ;
-- __q ;
std :: iter_swap ( __p , __q ) ;
}
__n %= __k ;
if ( __n == 0 )
return ;
std :: swap ( __n , __k ) ;
}
}
}
#1673
template < typename _ForwardIterator >
inline void
rotate ( _ForwardIterator __first , _ForwardIterator __middle ,
_ForwardIterator __last )
{



;
;

typedef typename iterator_traits < _ForwardIterator > :: iterator_category
_IterType ;
std :: __rotate ( __first , __middle , __last , _IterType ( ) ) ;
}
#1709
template < typename _ForwardIterator , typename _OutputIterator >
_OutputIterator
rotate_copy ( _ForwardIterator __first , _ForwardIterator __middle ,
_ForwardIterator __last , _OutputIterator __result )
{




;
;

return std :: copy ( __first , __middle ,
std :: copy ( __middle , __last , __result ) ) ;
}


template < typename _ForwardIterator , typename _Predicate >
_ForwardIterator
__partition ( _ForwardIterator __first , _ForwardIterator __last ,
_Predicate __pred , forward_iterator_tag )
{
if ( __first == __last )
return __first ;

while ( __pred ( * __first ) )
if ( ++ __first == __last )
return __first ;

_ForwardIterator __next = __first ;

while ( ++ __next != __last )
if ( __pred ( * __next ) )
{
std :: iter_swap ( __first , __next ) ;
++ __first ;
}

return __first ;
}


template < typename _BidirectionalIterator , typename _Predicate >
_BidirectionalIterator
__partition ( _BidirectionalIterator __first , _BidirectionalIterator __last ,
_Predicate __pred , bidirectional_iterator_tag )
{
while ( true )
{
while ( true )
if ( __first == __last )
return __first ;
else if ( __pred ( * __first ) )
++ __first ;
else
break ;
-- __last ;
while ( true )
if ( __first == __last )
return __first ;
else if ( ! bool ( __pred ( * __last ) ) )
-- __last ;
else
break ;
std :: iter_swap ( __first , __last ) ;
++ __first ;
}
}
#1783
template < typename _ForwardIterator , typename _Predicate , typename _Distance >
_ForwardIterator
__inplace_stable_partition ( _ForwardIterator __first ,
_Predicate __pred , _Distance __len )
{
if ( __len == 1 )
return __first ;
_ForwardIterator __middle = __first ;
std :: advance ( __middle , __len / 2 ) ;
_ForwardIterator __left_split =
std :: __inplace_stable_partition ( __first , __pred , __len / 2 ) ;


_Distance __right_len = __len - __len / 2 ;
_ForwardIterator __right_split =
std :: __find_if_not_n ( __middle , __right_len , __pred ) ;
if ( __right_len )
__right_split = std :: __inplace_stable_partition ( __middle ,
__pred ,
__right_len ) ;
std :: rotate ( __left_split , __middle , __right_split ) ;
std :: advance ( __left_split , std :: distance ( __middle , __right_split ) ) ;
return __left_split ;
}
#1814
template < typename _ForwardIterator , typename _Pointer , typename _Predicate ,
typename _Distance >
_ForwardIterator
__stable_partition_adaptive ( _ForwardIterator __first ,
_ForwardIterator __last ,
_Predicate __pred , _Distance __len ,
_Pointer __buffer ,
_Distance __buffer_size )
{
if ( __len <= __buffer_size )
{
_ForwardIterator __result1 = __first ;
_Pointer __result2 = __buffer ;



* __result2 = std :: move ( * __first ) ;
++ __result2 ;
++ __first ;
for ( ; __first != __last ; ++ __first )
if ( __pred ( * __first ) )
{
* __result1 = std :: move ( * __first ) ;
++ __result1 ;
}
else
{
* __result2 = std :: move ( * __first ) ;
++ __result2 ;
}
std :: move ( __buffer , __result2 , __result1 ) ;
return __result1 ;
}
else
{
_ForwardIterator __middle = __first ;
std :: advance ( __middle , __len / 2 ) ;
_ForwardIterator __left_split =
std :: __stable_partition_adaptive ( __first , __middle , __pred ,
__len / 2 , __buffer ,
__buffer_size ) ;


_Distance __right_len = __len - __len / 2 ;
_ForwardIterator __right_split =
std :: __find_if_not_n ( __middle , __right_len , __pred ) ;
if ( __right_len )
__right_split =
std :: __stable_partition_adaptive ( __right_split , __last , __pred ,
__right_len ,
__buffer , __buffer_size ) ;
std :: rotate ( __left_split , __middle , __right_split ) ;
std :: advance ( __left_split , std :: distance ( __middle , __right_split ) ) ;
return __left_split ;
}
}
#1888
template < typename _ForwardIterator , typename _Predicate >
_ForwardIterator
stable_partition ( _ForwardIterator __first , _ForwardIterator __last ,
_Predicate __pred )
{





;

__first = std :: __find_if_not ( __first , __last , __pred ) ;

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

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


template < typename _RandomAccessIterator >
void
__heap_select ( _RandomAccessIterator __first ,
_RandomAccessIterator __middle ,
_RandomAccessIterator __last )
{
std :: make_heap ( __first , __middle ) ;
for ( _RandomAccessIterator __i = __middle ; __i < __last ; ++ __i )
if ( * __i < * __first )
std :: __pop_heap ( __first , __middle , __i ) ;
}


template < typename _RandomAccessIterator , typename _Compare >
void
__heap_select ( _RandomAccessIterator __first ,
_RandomAccessIterator __middle ,
_RandomAccessIterator __last , _Compare __comp )
{
std :: make_heap ( __first , __middle , __comp ) ;
for ( _RandomAccessIterator __i = __middle ; __i < __last ; ++ __i )
if ( __comp ( * __i , * __first ) )
std :: __pop_heap ( __first , __middle , __i , __comp ) ;
}
#1972
template < typename _InputIterator , typename _RandomAccessIterator >
_RandomAccessIterator
partial_sort_copy ( _InputIterator __first , _InputIterator __last ,
_RandomAccessIterator __result_first ,
_RandomAccessIterator __result_last )
{
typedef typename iterator_traits < _InputIterator > :: value_type
_InputValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_OutputValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;
#1992
;
;

if ( __result_first == __result_last )
return __result_last ;
_RandomAccessIterator __result_real_last = __result_first ;
while ( __first != __last && __result_real_last != __result_last )
{
* __result_real_last = * __first ;
++ __result_real_last ;
++ __first ;
}
std :: make_heap ( __result_first , __result_real_last ) ;
while ( __first != __last )
{
if ( * __first < * __result_first )
std :: __adjust_heap ( __result_first , _DistanceType ( 0 ) ,
_DistanceType ( __result_real_last
- __result_first ) ,
_InputValueType ( * __first ) ) ;
++ __first ;
}
std :: sort_heap ( __result_first , __result_real_last ) ;
return __result_real_last ;
}
#2038
template < typename _InputIterator , typename _RandomAccessIterator , typename _Compare >
_RandomAccessIterator
partial_sort_copy ( _InputIterator __first , _InputIterator __last ,
_RandomAccessIterator __result_first ,
_RandomAccessIterator __result_last ,
_Compare __comp )
{
typedef typename iterator_traits < _InputIterator > :: value_type
_InputValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_OutputValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;
#2062
;
;

if ( __result_first == __result_last )
return __result_last ;
_RandomAccessIterator __result_real_last = __result_first ;
while ( __first != __last && __result_real_last != __result_last )
{
* __result_real_last = * __first ;
++ __result_real_last ;
++ __first ;
}
std :: make_heap ( __result_first , __result_real_last , __comp ) ;
while ( __first != __last )
{
if ( __comp ( * __first , * __result_first ) )
std :: __adjust_heap ( __result_first , _DistanceType ( 0 ) ,
_DistanceType ( __result_real_last
- __result_first ) ,
_InputValueType ( * __first ) ,
__comp ) ;
++ __first ;
}
std :: sort_heap ( __result_first , __result_real_last , __comp ) ;
return __result_real_last ;
}


template < typename _RandomAccessIterator >
void
__unguarded_linear_insert ( _RandomAccessIterator __last )
{
typename iterator_traits < _RandomAccessIterator > :: value_type
__val = std :: move ( * __last ) ;
_RandomAccessIterator __next = __last ;
-- __next ;
while ( __val < * __next )
{
* __last = std :: move ( * __next ) ;
__last = __next ;
-- __next ;
}
* __last = std :: move ( __val ) ;
}


template < typename _RandomAccessIterator , typename _Compare >
void
__unguarded_linear_insert ( _RandomAccessIterator __last ,
_Compare __comp )
{
typename iterator_traits < _RandomAccessIterator > :: value_type
__val = std :: move ( * __last ) ;
_RandomAccessIterator __next = __last ;
-- __next ;
while ( __comp ( __val , * __next ) )
{
* __last = std :: move ( * __next ) ;
__last = __next ;
-- __next ;
}
* __last = std :: move ( __val ) ;
}


template < typename _RandomAccessIterator >
void
__insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last )
{
if ( __first == __last )
return ;

for ( _RandomAccessIterator __i = __first + 1 ; __i != __last ; ++ __i )
{
if ( * __i < * __first )
{
typename iterator_traits < _RandomAccessIterator > :: value_type
__val = std :: move ( * __i ) ;
std :: move_backward ( __first , __i , __i + 1 ) ;
* __first = std :: move ( __val ) ;
}
else
std :: __unguarded_linear_insert ( __i ) ;
}
}


template < typename _RandomAccessIterator , typename _Compare >
void
__insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last , _Compare __comp )
{
if ( __first == __last ) return ;

for ( _RandomAccessIterator __i = __first + 1 ; __i != __last ; ++ __i )
{
if ( __comp ( * __i , * __first ) )
{
typename iterator_traits < _RandomAccessIterator > :: value_type
__val = std :: move ( * __i ) ;
std :: move_backward ( __first , __i , __i + 1 ) ;
* __first = std :: move ( __val ) ;
}
else
std :: __unguarded_linear_insert ( __i , __comp ) ;
}
}


template < typename _RandomAccessIterator >
inline void
__unguarded_insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;

for ( _RandomAccessIterator __i = __first ; __i != __last ; ++ __i )
std :: __unguarded_linear_insert ( __i ) ;
}


template < typename _RandomAccessIterator , typename _Compare >
inline void
__unguarded_insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last , _Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;

for ( _RandomAccessIterator __i = __first ; __i != __last ; ++ __i )
std :: __unguarded_linear_insert ( __i , __comp ) ;
}





enum { _S_threshold = 16 } ;


template < typename _RandomAccessIterator >
void
__final_insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last )
{
if ( __last - __first > int ( _S_threshold ) )
{
std :: __insertion_sort ( __first , __first + int ( _S_threshold ) ) ;
std :: __unguarded_insertion_sort ( __first + int ( _S_threshold ) , __last ) ;
}
else
std :: __insertion_sort ( __first , __last ) ;
}


template < typename _RandomAccessIterator , typename _Compare >
void
__final_insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last , _Compare __comp )
{
if ( __last - __first > int ( _S_threshold ) )
{
std :: __insertion_sort ( __first , __first + int ( _S_threshold ) , __comp ) ;
std :: __unguarded_insertion_sort ( __first + int ( _S_threshold ) , __last ,
__comp ) ;
}
else
std :: __insertion_sort ( __first , __last , __comp ) ;
}


template < typename _RandomAccessIterator , typename _Tp >
_RandomAccessIterator
__unguarded_partition ( _RandomAccessIterator __first ,
_RandomAccessIterator __last , const _Tp & __pivot )
{
while ( true )
{
while ( * __first < __pivot )
++ __first ;
-- __last ;
while ( __pivot < * __last )
-- __last ;
if ( ! ( __first < __last ) )
return __first ;
std :: iter_swap ( __first , __last ) ;
++ __first ;
}
}


template < typename _RandomAccessIterator , typename _Tp , typename _Compare >
_RandomAccessIterator
__unguarded_partition ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
const _Tp & __pivot , _Compare __comp )
{
while ( true )
{
while ( __comp ( * __first , __pivot ) )
++ __first ;
-- __last ;
while ( __comp ( __pivot , * __last ) )
-- __last ;
if ( ! ( __first < __last ) )
return __first ;
std :: iter_swap ( __first , __last ) ;
++ __first ;
}
}


template < typename _RandomAccessIterator >
inline _RandomAccessIterator
__unguarded_partition_pivot ( _RandomAccessIterator __first ,
_RandomAccessIterator __last )
{
_RandomAccessIterator __mid = __first + ( __last - __first ) / 2 ;
std :: __move_median_to_first ( __first , __first + 1 , __mid , ( __last - 2 ) ) ;
return std :: __unguarded_partition ( __first + 1 , __last , * __first ) ;
}



template < typename _RandomAccessIterator , typename _Compare >
inline _RandomAccessIterator
__unguarded_partition_pivot ( _RandomAccessIterator __first ,
_RandomAccessIterator __last , _Compare __comp )
{
_RandomAccessIterator __mid = __first + ( __last - __first ) / 2 ;
std :: __move_median_to_first ( __first , __first + 1 , __mid , ( __last - 2 ) ,
__comp ) ;
return std :: __unguarded_partition ( __first + 1 , __last , * __first , __comp ) ;
}


template < typename _RandomAccessIterator , typename _Size >
void
__introsort_loop ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Size __depth_limit )
{
while ( __last - __first > int ( _S_threshold ) )
{
if ( __depth_limit == 0 )
{
std :: partial_sort ( __first , __last , __last ) ;
return ;
}
-- __depth_limit ;
_RandomAccessIterator __cut =
std :: __unguarded_partition_pivot ( __first , __last ) ;
std :: __introsort_loop ( __cut , __last , __depth_limit ) ;
__last = __cut ;
}
}


template < typename _RandomAccessIterator , typename _Size , typename _Compare >
void
__introsort_loop ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Size __depth_limit , _Compare __comp )
{
while ( __last - __first > int ( _S_threshold ) )
{
if ( __depth_limit == 0 )
{
std :: partial_sort ( __first , __last , __last , __comp ) ;
return ;
}
-- __depth_limit ;
_RandomAccessIterator __cut =
std :: __unguarded_partition_pivot ( __first , __last , __comp ) ;
std :: __introsort_loop ( __cut , __last , __depth_limit , __comp ) ;
__last = __cut ;
}
}



template < typename _RandomAccessIterator , typename _Size >
void
__introselect ( _RandomAccessIterator __first , _RandomAccessIterator __nth ,
_RandomAccessIterator __last , _Size __depth_limit )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;

while ( __last - __first > 3 )
{
if ( __depth_limit == 0 )
{
std :: __heap_select ( __first , __nth + 1 , __last ) ;


std :: iter_swap ( __first , __nth ) ;
return ;
}
-- __depth_limit ;
_RandomAccessIterator __cut =
std :: __unguarded_partition_pivot ( __first , __last ) ;
if ( __cut <= __nth )
__first = __cut ;
else
__last = __cut ;
}
std :: __insertion_sort ( __first , __last ) ;
}

template < typename _RandomAccessIterator , typename _Size , typename _Compare >
void
__introselect ( _RandomAccessIterator __first , _RandomAccessIterator __nth ,
_RandomAccessIterator __last , _Size __depth_limit ,
_Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;

while ( __last - __first > 3 )
{
if ( __depth_limit == 0 )
{
std :: __heap_select ( __first , __nth + 1 , __last , __comp ) ;

std :: iter_swap ( __first , __nth ) ;
return ;
}
-- __depth_limit ;
_RandomAccessIterator __cut =
std :: __unguarded_partition_pivot ( __first , __last , __comp ) ;
if ( __cut <= __nth )
__first = __cut ;
else
__last = __cut ;
}
std :: __insertion_sort ( __first , __last , __comp ) ;
}
#2423
template < typename _ForwardIterator , typename _Tp , typename _Compare >
_ForwardIterator
lower_bound ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val , _Compare __comp )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _ForwardIterator > :: difference_type
_DistanceType ;
#2438
;

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

while ( __len > 0 )
{
_DistanceType __half = __len >> 1 ;
_ForwardIterator __middle = __first ;
std :: advance ( __middle , __half ) ;
if ( __comp ( * __middle , __val ) )
{
__first = __middle ;
++ __first ;
__len = __len - __half - 1 ;
}
else
__len = __half ;
}
return __first ;
}
#2470
template < typename _ForwardIterator , typename _Tp >
_ForwardIterator
upper_bound ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _ForwardIterator > :: difference_type
_DistanceType ;




;

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

while ( __len > 0 )
{
_DistanceType __half = __len >> 1 ;
_ForwardIterator __middle = __first ;
std :: advance ( __middle , __half ) ;
if ( __val < * __middle )
__len = __half ;
else
{
__first = __middle ;
++ __first ;
__len = __len - __half - 1 ;
}
}
return __first ;
}
#2519
template < typename _ForwardIterator , typename _Tp , typename _Compare >
_ForwardIterator
upper_bound ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val , _Compare __comp )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _ForwardIterator > :: difference_type
_DistanceType ;
#2534
;

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

while ( __len > 0 )
{
_DistanceType __half = __len >> 1 ;
_ForwardIterator __middle = __first ;
std :: advance ( __middle , __half ) ;
if ( __comp ( __val , * __middle ) )
__len = __half ;
else
{
__first = __middle ;
++ __first ;
__len = __len - __half - 1 ;
}
}
return __first ;
}
#2572
template < typename _ForwardIterator , typename _Tp >
pair < _ForwardIterator , _ForwardIterator >
equal_range ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _ForwardIterator > :: difference_type
_DistanceType ;





;
;

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

while ( __len > 0 )
{
_DistanceType __half = __len >> 1 ;
_ForwardIterator __middle = __first ;
std :: advance ( __middle , __half ) ;
if ( * __middle < __val )
{
__first = __middle ;
++ __first ;
__len = __len - __half - 1 ;
}
else if ( __val < * __middle )
__len = __half ;
else
{
_ForwardIterator __left = std :: lower_bound ( __first , __middle ,
__val ) ;
std :: advance ( __first , __len ) ;
_ForwardIterator __right = std :: upper_bound ( ++ __middle , __first ,
__val ) ;
return pair < _ForwardIterator , _ForwardIterator > ( __left , __right ) ;
}
}
return pair < _ForwardIterator , _ForwardIterator > ( __first , __first ) ;
}
#2634
template < typename _ForwardIterator , typename _Tp , typename _Compare >
pair < _ForwardIterator , _ForwardIterator >
equal_range ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val , _Compare __comp )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _ForwardIterator > :: difference_type
_DistanceType ;
#2651
;

;

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

while ( __len > 0 )
{
_DistanceType __half = __len >> 1 ;
_ForwardIterator __middle = __first ;
std :: advance ( __middle , __half ) ;
if ( __comp ( * __middle , __val ) )
{
__first = __middle ;
++ __first ;
__len = __len - __half - 1 ;
}
else if ( __comp ( __val , * __middle ) )
__len = __half ;
else
{
_ForwardIterator __left = std :: lower_bound ( __first , __middle ,
__val , __comp ) ;
std :: advance ( __first , __len ) ;
_ForwardIterator __right = std :: upper_bound ( ++ __middle , __first ,
__val , __comp ) ;
return pair < _ForwardIterator , _ForwardIterator > ( __left , __right ) ;
}
}
return pair < _ForwardIterator , _ForwardIterator > ( __first , __first ) ;
}
#2695
template < typename _ForwardIterator , typename _Tp >
bool
binary_search ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;




;
;

_ForwardIterator __i = std :: lower_bound ( __first , __last , __val ) ;
return __i != __last && ! ( __val < * __i ) ;
}
#2728
template < typename _ForwardIterator , typename _Tp , typename _Compare >
bool
binary_search ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __val , _Compare __comp )
{
typedef typename iterator_traits < _ForwardIterator > :: value_type
_ValueType ;
#2741
;

;

_ForwardIterator __i = std :: lower_bound ( __first , __last , __val , __comp ) ;
return __i != __last && ! bool ( __comp ( __val , * __i ) ) ;
}




template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator >
void
__move_merge_adaptive ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result )
{
while ( __first1 != __last1 && __first2 != __last2 )
{
if ( * __first2 < * __first1 )
{
* __result = std :: move ( * __first2 ) ;
++ __first2 ;
}
else
{
* __result = std :: move ( * __first1 ) ;
++ __first1 ;
}
++ __result ;
}
if ( __first1 != __last1 )
std :: move ( __first1 , __last1 , __result ) ;
}


template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _Compare >
void
__move_merge_adaptive ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result , _Compare __comp )
{
while ( __first1 != __last1 && __first2 != __last2 )
{
if ( __comp ( * __first2 , * __first1 ) )
{
* __result = std :: move ( * __first2 ) ;
++ __first2 ;
}
else
{
* __result = std :: move ( * __first1 ) ;
++ __first1 ;
}
++ __result ;
}
if ( __first1 != __last1 )
std :: move ( __first1 , __last1 , __result ) ;
}


template < typename _BidirectionalIterator1 , typename _BidirectionalIterator2 ,
typename _BidirectionalIterator3 >
void
__move_merge_adaptive_backward ( _BidirectionalIterator1 __first1 ,
_BidirectionalIterator1 __last1 ,
_BidirectionalIterator2 __first2 ,
_BidirectionalIterator2 __last2 ,
_BidirectionalIterator3 __result )
{
if ( __first1 == __last1 )
{
std :: move_backward ( __first2 , __last2 , __result ) ;
return ;
}
else if ( __first2 == __last2 )
return ;

-- __last1 ;
-- __last2 ;
while ( true )
{
if ( * __last2 < * __last1 )
{
* -- __result = std :: move ( * __last1 ) ;
if ( __first1 == __last1 )
{
std :: move_backward ( __first2 , ++ __last2 , __result ) ;
return ;
}
-- __last1 ;
}
else
{
* -- __result = std :: move ( * __last2 ) ;
if ( __first2 == __last2 )
return ;
-- __last2 ;
}
}
}


template < typename _BidirectionalIterator1 , typename _BidirectionalIterator2 ,
typename _BidirectionalIterator3 , typename _Compare >
void
__move_merge_adaptive_backward ( _BidirectionalIterator1 __first1 ,
_BidirectionalIterator1 __last1 ,
_BidirectionalIterator2 __first2 ,
_BidirectionalIterator2 __last2 ,
_BidirectionalIterator3 __result ,
_Compare __comp )
{
if ( __first1 == __last1 )
{
std :: move_backward ( __first2 , __last2 , __result ) ;
return ;
}
else if ( __first2 == __last2 )
return ;

-- __last1 ;
-- __last2 ;
while ( true )
{
if ( __comp ( * __last2 , * __last1 ) )
{
* -- __result = std :: move ( * __last1 ) ;
if ( __first1 == __last1 )
{
std :: move_backward ( __first2 , ++ __last2 , __result ) ;
return ;
}
-- __last1 ;
}
else
{
* -- __result = std :: move ( * __last2 ) ;
if ( __first2 == __last2 )
return ;
-- __last2 ;
}
}
}


template < typename _BidirectionalIterator1 , typename _BidirectionalIterator2 ,
typename _Distance >
_BidirectionalIterator1
__rotate_adaptive ( _BidirectionalIterator1 __first ,
_BidirectionalIterator1 __middle ,
_BidirectionalIterator1 __last ,
_Distance __len1 , _Distance __len2 ,
_BidirectionalIterator2 __buffer ,
_Distance __buffer_size )
{
_BidirectionalIterator2 __buffer_end ;
if ( __len1 > __len2 && __len2 <= __buffer_size )
{
if ( __len2 )
{
__buffer_end = std :: move ( __middle , __last , __buffer ) ;
std :: move_backward ( __first , __middle , __last ) ;
return std :: move ( __buffer , __buffer_end , __first ) ;
}
else
return __first ;
}
else if ( __len1 <= __buffer_size )
{
if ( __len1 )
{
__buffer_end = std :: move ( __first , __middle , __buffer ) ;
std :: move ( __middle , __last , __first ) ;
return std :: move_backward ( __buffer , __buffer_end , __last ) ;
}
else
return __last ;
}
else
{
std :: rotate ( __first , __middle , __last ) ;
std :: advance ( __first , std :: distance ( __middle , __last ) ) ;
return __first ;
}
}


template < typename _BidirectionalIterator , typename _Distance ,
typename _Pointer >
void
__merge_adaptive ( _BidirectionalIterator __first ,
_BidirectionalIterator __middle ,
_BidirectionalIterator __last ,
_Distance __len1 , _Distance __len2 ,
_Pointer __buffer , _Distance __buffer_size )
{
if ( __len1 <= __len2 && __len1 <= __buffer_size )
{
_Pointer __buffer_end = std :: move ( __first , __middle , __buffer ) ;
std :: __move_merge_adaptive ( __buffer , __buffer_end , __middle , __last ,
__first ) ;
}
else if ( __len2 <= __buffer_size )
{
_Pointer __buffer_end = std :: move ( __middle , __last , __buffer ) ;
std :: __move_merge_adaptive_backward ( __first , __middle , __buffer ,
__buffer_end , __last ) ;
}
else
{
_BidirectionalIterator __first_cut = __first ;
_BidirectionalIterator __second_cut = __middle ;
_Distance __len11 = 0 ;
_Distance __len22 = 0 ;
if ( __len1 > __len2 )
{
__len11 = __len1 / 2 ;
std :: advance ( __first_cut , __len11 ) ;
__second_cut = std :: lower_bound ( __middle , __last ,
* __first_cut ) ;
__len22 = std :: distance ( __middle , __second_cut ) ;
}
else
{
__len22 = __len2 / 2 ;
std :: advance ( __second_cut , __len22 ) ;
__first_cut = std :: upper_bound ( __first , __middle ,
* __second_cut ) ;
__len11 = std :: distance ( __first , __first_cut ) ;
}
_BidirectionalIterator __new_middle =
std :: __rotate_adaptive ( __first_cut , __middle , __second_cut ,
__len1 - __len11 , __len22 , __buffer ,
__buffer_size ) ;
std :: __merge_adaptive ( __first , __first_cut , __new_middle , __len11 ,
__len22 , __buffer , __buffer_size ) ;
std :: __merge_adaptive ( __new_middle , __second_cut , __last ,
__len1 - __len11 ,
__len2 - __len22 , __buffer , __buffer_size ) ;
}
}


template < typename _BidirectionalIterator , typename _Distance ,
typename _Pointer , typename _Compare >
void
__merge_adaptive ( _BidirectionalIterator __first ,
_BidirectionalIterator __middle ,
_BidirectionalIterator __last ,
_Distance __len1 , _Distance __len2 ,
_Pointer __buffer , _Distance __buffer_size ,
_Compare __comp )
{
if ( __len1 <= __len2 && __len1 <= __buffer_size )
{
_Pointer __buffer_end = std :: move ( __first , __middle , __buffer ) ;
std :: __move_merge_adaptive ( __buffer , __buffer_end , __middle , __last ,
__first , __comp ) ;
}
else if ( __len2 <= __buffer_size )
{
_Pointer __buffer_end = std :: move ( __middle , __last , __buffer ) ;
std :: __move_merge_adaptive_backward ( __first , __middle , __buffer ,
__buffer_end , __last , __comp ) ;
}
else
{
_BidirectionalIterator __first_cut = __first ;
_BidirectionalIterator __second_cut = __middle ;
_Distance __len11 = 0 ;
_Distance __len22 = 0 ;
if ( __len1 > __len2 )
{
__len11 = __len1 / 2 ;
std :: advance ( __first_cut , __len11 ) ;
__second_cut = std :: lower_bound ( __middle , __last , * __first_cut ,
__comp ) ;
__len22 = std :: distance ( __middle , __second_cut ) ;
}
else
{
__len22 = __len2 / 2 ;
std :: advance ( __second_cut , __len22 ) ;
__first_cut = std :: upper_bound ( __first , __middle , * __second_cut ,
__comp ) ;
__len11 = std :: distance ( __first , __first_cut ) ;
}
_BidirectionalIterator __new_middle =
std :: __rotate_adaptive ( __first_cut , __middle , __second_cut ,
__len1 - __len11 , __len22 , __buffer ,
__buffer_size ) ;
std :: __merge_adaptive ( __first , __first_cut , __new_middle , __len11 ,
__len22 , __buffer , __buffer_size , __comp ) ;
std :: __merge_adaptive ( __new_middle , __second_cut , __last ,
__len1 - __len11 ,
__len2 - __len22 , __buffer ,
__buffer_size , __comp ) ;
}
}


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


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





;
;

if ( __first == __middle || __middle == __last )
return ;

_DistanceType __len1 = std :: distance ( __first , __middle ) ;
_DistanceType __len2 = std :: distance ( __middle , __last ) ;

_Temporary_buffer < _BidirectionalIterator , _ValueType > __buf ( __first ,
__last ) ;
if ( __buf . begin ( ) == 0 )
std :: __merge_without_buffer ( __first , __middle , __last , __len1 , __len2 ) ;
else
std :: __merge_adaptive ( __first , __middle , __last , __len1 , __len2 ,
__buf . begin ( ) , _DistanceType ( __buf . size ( ) ) ) ;
}
#3207
template < typename _BidirectionalIterator , typename _Compare >
void
inplace_merge ( _BidirectionalIterator __first ,
_BidirectionalIterator __middle ,
_BidirectionalIterator __last ,
_Compare __comp )
{
typedef typename iterator_traits < _BidirectionalIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _BidirectionalIterator > :: difference_type
_DistanceType ;
#3224
;
;

if ( __first == __middle || __middle == __last )
return ;

const _DistanceType __len1 = std :: distance ( __first , __middle ) ;
const _DistanceType __len2 = std :: distance ( __middle , __last ) ;

_Temporary_buffer < _BidirectionalIterator , _ValueType > __buf ( __first ,
__last ) ;
if ( __buf . begin ( ) == 0 )
std :: __merge_without_buffer ( __first , __middle , __last , __len1 ,
__len2 , __comp ) ;
else
std :: __merge_adaptive ( __first , __middle , __last , __len1 , __len2 ,
__buf . begin ( ) , _DistanceType ( __buf . size ( ) ) ,
__comp ) ;
}



template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator >
_OutputIterator
__move_merge ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result )
{
while ( __first1 != __last1 && __first2 != __last2 )
{
if ( * __first2 < * __first1 )
{
* __result = std :: move ( * __first2 ) ;
++ __first2 ;
}
else
{
* __result = std :: move ( * __first1 ) ;
++ __first1 ;
}
++ __result ;
}
return

std :: move ( __first2 , __last2 , std :: move ( __first1 , __last1 , __result ) ) ;
}


template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _Compare >
_OutputIterator
__move_merge ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result , _Compare __comp )
{
while ( __first1 != __last1 && __first2 != __last2 )
{
if ( __comp ( * __first2 , * __first1 ) )
{
* __result = std :: move ( * __first2 ) ;
++ __first2 ;
}
else
{
* __result = std :: move ( * __first1 ) ;
++ __first1 ;
}
++ __result ;
}
return

std :: move ( __first2 , __last2 , std :: move ( __first1 , __last1 , __result ) ) ;
}

template < typename _RandomAccessIterator1 , typename _RandomAccessIterator2 ,
typename _Distance >
void
__merge_sort_loop ( _RandomAccessIterator1 __first ,
_RandomAccessIterator1 __last ,
_RandomAccessIterator2 __result ,
_Distance __step_size )
{
const _Distance __two_step = 2 * __step_size ;

while ( __last - __first >= __two_step )
{
__result = std :: __move_merge ( __first , __first + __step_size ,
__first + __step_size ,
__first + __two_step , __result ) ;
__first += __two_step ;
}

__step_size = std :: min ( _Distance ( __last - __first ) , __step_size ) ;
std :: __move_merge ( __first , __first + __step_size ,
__first + __step_size , __last , __result ) ;
}

template < typename _RandomAccessIterator1 , typename _RandomAccessIterator2 ,
typename _Distance , typename _Compare >
void
__merge_sort_loop ( _RandomAccessIterator1 __first ,
_RandomAccessIterator1 __last ,
_RandomAccessIterator2 __result , _Distance __step_size ,
_Compare __comp )
{
const _Distance __two_step = 2 * __step_size ;

while ( __last - __first >= __two_step )
{
__result = std :: __move_merge ( __first , __first + __step_size ,
__first + __step_size ,
__first + __two_step ,
__result , __comp ) ;
__first += __two_step ;
}
__step_size = std :: min ( _Distance ( __last - __first ) , __step_size ) ;

std :: __move_merge ( __first , __first + __step_size ,
__first + __step_size , __last , __result , __comp ) ;
}

template < typename _RandomAccessIterator , typename _Distance >
void
__chunk_insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Distance __chunk_size )
{
while ( __last - __first >= __chunk_size )
{
std :: __insertion_sort ( __first , __first + __chunk_size ) ;
__first += __chunk_size ;
}
std :: __insertion_sort ( __first , __last ) ;
}

template < typename _RandomAccessIterator , typename _Distance ,
typename _Compare >
void
__chunk_insertion_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Distance __chunk_size , _Compare __comp )
{
while ( __last - __first >= __chunk_size )
{
std :: __insertion_sort ( __first , __first + __chunk_size , __comp ) ;
__first += __chunk_size ;
}
std :: __insertion_sort ( __first , __last , __comp ) ;
}

enum { _S_chunk_size = 7 } ;

template < typename _RandomAccessIterator , typename _Pointer >
void
__merge_sort_with_buffer ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Pointer __buffer )
{
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_Distance ;

const _Distance __len = __last - __first ;
const _Pointer __buffer_last = __buffer + __len ;

_Distance __step_size = _S_chunk_size ;
std :: __chunk_insertion_sort ( __first , __last , __step_size ) ;

while ( __step_size < __len )
{
std :: __merge_sort_loop ( __first , __last , __buffer , __step_size ) ;
__step_size *= 2 ;
std :: __merge_sort_loop ( __buffer , __buffer_last , __first , __step_size ) ;
__step_size *= 2 ;
}
}

template < typename _RandomAccessIterator , typename _Pointer , typename _Compare >
void
__merge_sort_with_buffer ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Pointer __buffer , _Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_Distance ;

const _Distance __len = __last - __first ;
const _Pointer __buffer_last = __buffer + __len ;

_Distance __step_size = _S_chunk_size ;
std :: __chunk_insertion_sort ( __first , __last , __step_size , __comp ) ;

while ( __step_size < __len )
{
std :: __merge_sort_loop ( __first , __last , __buffer ,
__step_size , __comp ) ;
__step_size *= 2 ;
std :: __merge_sort_loop ( __buffer , __buffer_last , __first ,
__step_size , __comp ) ;
__step_size *= 2 ;
}
}

template < typename _RandomAccessIterator , typename _Pointer ,
typename _Distance >
void
__stable_sort_adaptive ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Pointer __buffer , _Distance __buffer_size )
{
const _Distance __len = ( __last - __first + 1 ) / 2 ;
const _RandomAccessIterator __middle = __first + __len ;
if ( __len > __buffer_size )
{
std :: __stable_sort_adaptive ( __first , __middle ,
__buffer , __buffer_size ) ;
std :: __stable_sort_adaptive ( __middle , __last ,
__buffer , __buffer_size ) ;
}
else
{
std :: __merge_sort_with_buffer ( __first , __middle , __buffer ) ;
std :: __merge_sort_with_buffer ( __middle , __last , __buffer ) ;
}
std :: __merge_adaptive ( __first , __middle , __last ,
_Distance ( __middle - __first ) ,
_Distance ( __last - __middle ) ,
__buffer , __buffer_size ) ;
}

template < typename _RandomAccessIterator , typename _Pointer ,
typename _Distance , typename _Compare >
void
__stable_sort_adaptive ( _RandomAccessIterator __first ,
_RandomAccessIterator __last ,
_Pointer __buffer , _Distance __buffer_size ,
_Compare __comp )
{
const _Distance __len = ( __last - __first + 1 ) / 2 ;
const _RandomAccessIterator __middle = __first + __len ;
if ( __len > __buffer_size )
{
std :: __stable_sort_adaptive ( __first , __middle , __buffer ,
__buffer_size , __comp ) ;
std :: __stable_sort_adaptive ( __middle , __last , __buffer ,
__buffer_size , __comp ) ;
}
else
{
std :: __merge_sort_with_buffer ( __first , __middle , __buffer , __comp ) ;
std :: __merge_sort_with_buffer ( __middle , __last , __buffer , __comp ) ;
}
std :: __merge_adaptive ( __first , __middle , __last ,
_Distance ( __middle - __first ) ,
_Distance ( __last - __middle ) ,
__buffer , __buffer_size ,
__comp ) ;
}


template < typename _RandomAccessIterator >
void
__inplace_stable_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last )
{
if ( __last - __first < 15 )
{
std :: __insertion_sort ( __first , __last ) ;
return ;
}
_RandomAccessIterator __middle = __first + ( __last - __first ) / 2 ;
std :: __inplace_stable_sort ( __first , __middle ) ;
std :: __inplace_stable_sort ( __middle , __last ) ;
std :: __merge_without_buffer ( __first , __middle , __last ,
__middle - __first ,
__last - __middle ) ;
}


template < typename _RandomAccessIterator , typename _Compare >
void
__inplace_stable_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __last , _Compare __comp )
{
if ( __last - __first < 15 )
{
std :: __insertion_sort ( __first , __last , __comp ) ;
return ;
}
_RandomAccessIterator __middle = __first + ( __last - __first ) / 2 ;
std :: __inplace_stable_sort ( __first , __middle , __comp ) ;
std :: __inplace_stable_sort ( __middle , __last , __comp ) ;
std :: __merge_without_buffer ( __first , __middle , __last ,
__middle - __first ,
__last - __middle ,
__comp ) ;
}
#3547
template < typename _InputIterator1 , typename _InputIterator2 >
bool
includes ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#3562
;
;

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

return __first2 == __last2 ;
}
#3597
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _Compare >
bool
includes ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_Compare __comp )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#3616
;
;

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

return __first2 == __last2 ;
}
#3652
template < typename _BidirectionalIterator >
bool
next_permutation ( _BidirectionalIterator __first ,
_BidirectionalIterator __last )
{





;

if ( __first == __last )
return false ;
_BidirectionalIterator __i = __first ;
++ __i ;
if ( __i == __last )
return false ;
__i = __last ;
-- __i ;

for ( ; ; )
{
_BidirectionalIterator __ii = __i ;
-- __i ;
if ( * __i < * __ii )
{
_BidirectionalIterator __j = __last ;
while ( ! ( * __i < * -- __j ) )
{ }
std :: iter_swap ( __i , __j ) ;
std :: reverse ( __ii , __last ) ;
return true ;
}
if ( __i == __first )
{
std :: reverse ( __first , __last ) ;
return false ;
}
}
}
#3709
template < typename _BidirectionalIterator , typename _Compare >
bool
next_permutation ( _BidirectionalIterator __first ,
_BidirectionalIterator __last , _Compare __comp )
{
#3720
;

if ( __first == __last )
return false ;
_BidirectionalIterator __i = __first ;
++ __i ;
if ( __i == __last )
return false ;
__i = __last ;
-- __i ;

for ( ; ; )
{
_BidirectionalIterator __ii = __i ;
-- __i ;
if ( __comp ( * __i , * __ii ) )
{
_BidirectionalIterator __j = __last ;
while ( ! bool ( __comp ( * __i , * -- __j ) ) )
{ }
std :: iter_swap ( __i , __j ) ;
std :: reverse ( __ii , __last ) ;
return true ;
}
if ( __i == __first )
{
std :: reverse ( __first , __last ) ;
return false ;
}
}
}
#3765
template < typename _BidirectionalIterator >
bool
prev_permutation ( _BidirectionalIterator __first ,
_BidirectionalIterator __last )
{





;

if ( __first == __last )
return false ;
_BidirectionalIterator __i = __first ;
++ __i ;
if ( __i == __last )
return false ;
__i = __last ;
-- __i ;

for ( ; ; )
{
_BidirectionalIterator __ii = __i ;
-- __i ;
if ( * __ii < * __i )
{
_BidirectionalIterator __j = __last ;
while ( ! ( * -- __j < * __i ) )
{ }
std :: iter_swap ( __i , __j ) ;
std :: reverse ( __ii , __last ) ;
return true ;
}
if ( __i == __first )
{
std :: reverse ( __first , __last ) ;
return false ;
}
}
}
#3822
template < typename _BidirectionalIterator , typename _Compare >
bool
prev_permutation ( _BidirectionalIterator __first ,
_BidirectionalIterator __last , _Compare __comp )
{
#3833
;

if ( __first == __last )
return false ;
_BidirectionalIterator __i = __first ;
++ __i ;
if ( __i == __last )
return false ;
__i = __last ;
-- __i ;

for ( ; ; )
{
_BidirectionalIterator __ii = __i ;
-- __i ;
if ( __comp ( * __ii , * __i ) )
{
_BidirectionalIterator __j = __last ;
while ( ! bool ( __comp ( * -- __j , * __i ) ) )
{ }
std :: iter_swap ( __i , __j ) ;
std :: reverse ( __ii , __last ) ;
return true ;
}
if ( __i == __first )
{
std :: reverse ( __first , __last ) ;
return false ;
}
}
}
#3882
template < typename _InputIterator , typename _OutputIterator , typename _Tp >
_OutputIterator
replace_copy ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result ,
const _Tp & __old_value , const _Tp & __new_value )
{
#3894
;

for ( ; __first != __last ; ++ __first , ++ __result )
if ( * __first == __old_value )
* __result = __new_value ;
else
* __result = * __first ;
return __result ;
}
#3919
template < typename _InputIterator , typename _OutputIterator ,
typename _Predicate , typename _Tp >
_OutputIterator
replace_copy_if ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result ,
_Predicate __pred , const _Tp & __new_value )
{
#3932
;

for ( ; __first != __last ; ++ __first , ++ __result )
if ( __pred ( * __first ) )
* __result = __new_value ;
else
* __result = * __first ;
return __result ;
}
#3950
template < typename _ForwardIterator >
inline bool
is_sorted ( _ForwardIterator __first , _ForwardIterator __last )
{ return std :: is_sorted_until ( __first , __last ) == __last ; }
#3964
template < typename _ForwardIterator , typename _Compare >
inline bool
is_sorted ( _ForwardIterator __first , _ForwardIterator __last ,
_Compare __comp )
{ return std :: is_sorted_until ( __first , __last , __comp ) == __last ; }
#3978
template < typename _ForwardIterator >
_ForwardIterator
is_sorted_until ( _ForwardIterator __first , _ForwardIterator __last )
{




;

if ( __first == __last )
return __last ;

_ForwardIterator __next = __first ;
for ( ++ __next ; __next != __last ; __first = __next , ++ __next )
if ( * __next < * __first )
return __next ;
return __next ;
}
#4007
template < typename _ForwardIterator , typename _Compare >
_ForwardIterator
is_sorted_until ( _ForwardIterator __first , _ForwardIterator __last ,
_Compare __comp )
{





;

if ( __first == __last )
return __last ;

_ForwardIterator __next = __first ;
for ( ++ __next ; __next != __last ; __first = __next , ++ __next )
if ( __comp ( * __next , * __first ) )
return __next ;
return __next ;
}
#4037
template < typename _Tp >
inline pair < const _Tp & , const _Tp & >
minmax ( const _Tp & __a , const _Tp & __b )
{



return __b < __a ? pair < const _Tp & , const _Tp & > ( __b , __a )
: pair < const _Tp & , const _Tp & > ( __a , __b ) ;
}
#4057
template < typename _Tp , typename _Compare >
inline pair < const _Tp & , const _Tp & >
minmax ( const _Tp & __a , const _Tp & __b , _Compare __comp )
{
return __comp ( __b , __a ) ? pair < const _Tp & , const _Tp & > ( __b , __a )
: pair < const _Tp & , const _Tp & > ( __a , __b ) ;
}
#4076
template < typename _ForwardIterator >
pair < _ForwardIterator , _ForwardIterator >
minmax_element ( _ForwardIterator __first , _ForwardIterator __last )
{




;

_ForwardIterator __next = __first ;
if ( __first == __last
|| ++ __next == __last )
return std :: make_pair ( __first , __first ) ;

_ForwardIterator __min , __max ;
if ( * __next < * __first )
{
__min = __next ;
__max = __first ;
}
else
{
__min = __first ;
__max = __next ;
}

__first = __next ;
++ __first ;

while ( __first != __last )
{
__next = __first ;
if ( ++ __next == __last )
{
if ( * __first < * __min )
__min = __first ;
else if ( ! ( * __first < * __max ) )
__max = __first ;
break ;
}

if ( * __next < * __first )
{
if ( * __next < * __min )
__min = __next ;
if ( ! ( * __first < * __max ) )
__max = __first ;
}
else
{
if ( * __first < * __min )
__min = __first ;
if ( ! ( * __next < * __max ) )
__max = __next ;
}

__first = __next ;
++ __first ;
}

return std :: make_pair ( __min , __max ) ;
}
#4152
template < typename _ForwardIterator , typename _Compare >
pair < _ForwardIterator , _ForwardIterator >
minmax_element ( _ForwardIterator __first , _ForwardIterator __last ,
_Compare __comp )
{





;

_ForwardIterator __next = __first ;
if ( __first == __last
|| ++ __next == __last )
return std :: make_pair ( __first , __first ) ;

_ForwardIterator __min , __max ;
if ( __comp ( * __next , * __first ) )
{
__min = __next ;
__max = __first ;
}
else
{
__min = __first ;
__max = __next ;
}

__first = __next ;
++ __first ;

while ( __first != __last )
{
__next = __first ;
if ( ++ __next == __last )
{
if ( __comp ( * __first , * __min ) )
__min = __first ;
else if ( ! __comp ( * __first , * __max ) )
__max = __first ;
break ;
}

if ( __comp ( * __next , * __first ) )
{
if ( __comp ( * __next , * __min ) )
__min = __next ;
if ( ! __comp ( * __first , * __max ) )
__max = __first ;
}
else
{
if ( __comp ( * __first , * __min ) )
__min = __first ;
if ( ! __comp ( * __next , * __max ) )
__max = __next ;
}

__first = __next ;
++ __first ;
}

return std :: make_pair ( __min , __max ) ;
}


template < typename _Tp >
inline _Tp
min ( initializer_list < _Tp > __l )
{ return * std :: min_element ( __l . begin ( ) , __l . end ( ) ) ; }

template < typename _Tp , typename _Compare >
inline _Tp
min ( initializer_list < _Tp > __l , _Compare __comp )
{ return * std :: min_element ( __l . begin ( ) , __l . end ( ) , __comp ) ; }

template < typename _Tp >
inline _Tp
max ( initializer_list < _Tp > __l )
{ return * std :: max_element ( __l . begin ( ) , __l . end ( ) ) ; }

template < typename _Tp , typename _Compare >
inline _Tp
max ( initializer_list < _Tp > __l , _Compare __comp )
{ return * std :: max_element ( __l . begin ( ) , __l . end ( ) , __comp ) ; }

template < typename _Tp >
inline pair < _Tp , _Tp >
minmax ( initializer_list < _Tp > __l )
{
pair < const _Tp * , const _Tp * > __p =
std :: minmax_element ( __l . begin ( ) , __l . end ( ) ) ;
return std :: make_pair ( * __p . first , * __p . second ) ;
}

template < typename _Tp , typename _Compare >
inline pair < _Tp , _Tp >
minmax ( initializer_list < _Tp > __l , _Compare __comp )
{
pair < const _Tp * , const _Tp * > __p =
std :: minmax_element ( __l . begin ( ) , __l . end ( ) , __comp ) ;
return std :: make_pair ( * __p . first , * __p . second ) ;
}
#4269
template < typename _ForwardIterator1 , typename _ForwardIterator2 >
bool
is_permutation ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 )
{


for ( ; __first1 != __last1 ; ++ __first1 , ++ __first2 )
if ( ! ( * __first1 == * __first2 ) )
break ;

if ( __first1 == __last1 )
return true ;



_ForwardIterator2 __last2 = __first2 ;
std :: advance ( __last2 , std :: distance ( __first1 , __last1 ) ) ;
for ( _ForwardIterator1 __scan = __first1 ; __scan != __last1 ; ++ __scan )
{
if ( __scan != std :: find ( __first1 , __scan , * __scan ) )
continue ;

auto __matches = std :: count ( __first2 , __last2 , * __scan ) ;
if ( 0 == __matches
|| std :: count ( __scan , __last1 , * __scan ) != __matches )
return false ;
}
return true ;
}
#4314
template < typename _ForwardIterator1 , typename _ForwardIterator2 ,
typename _BinaryPredicate >
bool
is_permutation ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 , _BinaryPredicate __pred )
{


for ( ; __first1 != __last1 ; ++ __first1 , ++ __first2 )
if ( ! bool ( __pred ( * __first1 , * __first2 ) ) )
break ;

if ( __first1 == __last1 )
return true ;



_ForwardIterator2 __last2 = __first2 ;
std :: advance ( __last2 , std :: distance ( __first1 , __last1 ) ) ;
for ( _ForwardIterator1 __scan = __first1 ; __scan != __last1 ; ++ __scan )
{
using std :: placeholders :: _1 ;

if ( __scan != std :: find_if ( __first1 , __scan ,
std :: bind ( __pred , _1 , * __scan ) ) )
continue ;

auto __matches = std :: count_if ( __first2 , __last2 ,
std :: bind ( __pred , _1 , * __scan ) ) ;
if ( 0 == __matches
|| std :: count_if ( __scan , __last1 ,
std :: bind ( __pred , _1 , * __scan ) ) != __matches )
return false ;
}
return true ;
}
#4364
template < typename _RandomAccessIterator ,
typename _UniformRandomNumberGenerator >
void
shuffle ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_UniformRandomNumberGenerator && __g )
{



;

if ( __first == __last )
return ;

typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;

typedef typename std :: make_unsigned < _DistanceType > :: type __ud_type ;
typedef typename std :: uniform_int_distribution < __ud_type > __distr_type ;
typedef typename __distr_type :: param_type __p_type ;
__distr_type __d ;

for ( _RandomAccessIterator __i = __first + 1 ; __i != __last ; ++ __i )
std :: iter_swap ( __i , __first + __d ( __g , __p_type ( 0 , __i - __first ) ) ) ;
}
#4409
template < typename _InputIterator , typename _Function >
_Function
for_each ( _InputIterator __first , _InputIterator __last , _Function __f )
{


;
for ( ; __first != __last ; ++ __first )
__f ( * __first ) ;
return std :: move ( __f ) ;
}
#4430
template < typename _InputIterator , typename _Tp >
inline _InputIterator
find ( _InputIterator __first , _InputIterator __last ,
const _Tp & __val )
{




;
return std :: __find ( __first , __last , __val ,
std :: __iterator_category ( __first ) ) ;
}
#4454
template < typename _InputIterator , typename _Predicate >
inline _InputIterator
find_if ( _InputIterator __first , _InputIterator __last ,
_Predicate __pred )
{




;
return std :: __find_if ( __first , __last , __pred ,
std :: __iterator_category ( __first ) ) ;
}
#4484
template < typename _InputIterator , typename _ForwardIterator >
_InputIterator
find_first_of ( _InputIterator __first1 , _InputIterator __last1 ,
_ForwardIterator __first2 , _ForwardIterator __last2 )
{
#4495
;
;

for ( ; __first1 != __last1 ; ++ __first1 )
for ( _ForwardIterator __iter = __first2 ; __iter != __last2 ; ++ __iter )
if ( * __first1 == * __iter )
return __first1 ;
return __last1 ;
}
#4524
template < typename _InputIterator , typename _ForwardIterator ,
typename _BinaryPredicate >
_InputIterator
find_first_of ( _InputIterator __first1 , _InputIterator __last1 ,
_ForwardIterator __first2 , _ForwardIterator __last2 ,
_BinaryPredicate __comp )
{
#4537
;
;

for ( ; __first1 != __last1 ; ++ __first1 )
for ( _ForwardIterator __iter = __first2 ; __iter != __last2 ; ++ __iter )
if ( __comp ( * __first1 , * __iter ) )
return __first1 ;
return __last1 ;
}
#4556
template < typename _ForwardIterator >
_ForwardIterator
adjacent_find ( _ForwardIterator __first , _ForwardIterator __last )
{




;
if ( __first == __last )
return __last ;
_ForwardIterator __next = __first ;
while ( ++ __next != __last )
{
if ( * __first == * __next )
return __first ;
__first = __next ;
}
return __last ;
}
#4588
template < typename _ForwardIterator , typename _BinaryPredicate >
_ForwardIterator
adjacent_find ( _ForwardIterator __first , _ForwardIterator __last ,
_BinaryPredicate __binary_pred )
{





;
if ( __first == __last )
return __last ;
_ForwardIterator __next = __first ;
while ( ++ __next != __last )
{
if ( __binary_pred ( * __first , * __next ) )
return __first ;
__first = __next ;
}
return __last ;
}
#4620
template < typename _InputIterator , typename _Tp >
typename iterator_traits < _InputIterator > :: difference_type
count ( _InputIterator __first , _InputIterator __last , const _Tp & __value )
{




;
typename iterator_traits < _InputIterator > :: difference_type __n = 0 ;
for ( ; __first != __last ; ++ __first )
if ( * __first == __value )
++ __n ;
return __n ;
}
#4645
template < typename _InputIterator , typename _Predicate >
typename iterator_traits < _InputIterator > :: difference_type
count_if ( _InputIterator __first , _InputIterator __last , _Predicate __pred )
{




;
typename iterator_traits < _InputIterator > :: difference_type __n = 0 ;
for ( ; __first != __last ; ++ __first )
if ( __pred ( * __first ) )
++ __n ;
return __n ;
}
#4687
template < typename _ForwardIterator1 , typename _ForwardIterator2 >
_ForwardIterator1
search ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 , _ForwardIterator2 __last2 )
{
#4698
;
;


if ( __first1 == __last1 || __first2 == __last2 )
return __first1 ;


_ForwardIterator2 __p1 ( __first2 ) ;
if ( ++ __p1 == __last2 )
return std :: find ( __first1 , __last1 , * __first2 ) ;


_ForwardIterator2 __p ;
_ForwardIterator1 __current = __first1 ;

for ( ; ; )
{
__first1 = std :: find ( __first1 , __last1 , * __first2 ) ;
if ( __first1 == __last1 )
return __last1 ;

__p = __p1 ;
__current = __first1 ;
if ( ++ __current == __last1 )
return __last1 ;

while ( * __current == * __p )
{
if ( ++ __p == __last2 )
return __first1 ;
if ( ++ __current == __last1 )
return __last1 ;
}
++ __first1 ;
}
return __first1 ;
}
#4758
template < typename _ForwardIterator1 , typename _ForwardIterator2 ,
typename _BinaryPredicate >
_ForwardIterator1
search ( _ForwardIterator1 __first1 , _ForwardIterator1 __last1 ,
_ForwardIterator2 __first2 , _ForwardIterator2 __last2 ,
_BinaryPredicate __predicate )
{
#4771
;
;


if ( __first1 == __last1 || __first2 == __last2 )
return __first1 ;


_ForwardIterator2 __p1 ( __first2 ) ;
if ( ++ __p1 == __last2 )
{
while ( __first1 != __last1
&& ! bool ( __predicate ( * __first1 , * __first2 ) ) )
++ __first1 ;
return __first1 ;
}


_ForwardIterator2 __p ;
_ForwardIterator1 __current = __first1 ;

for ( ; ; )
{
while ( __first1 != __last1
&& ! bool ( __predicate ( * __first1 , * __first2 ) ) )
++ __first1 ;
if ( __first1 == __last1 )
return __last1 ;

__p = __p1 ;
__current = __first1 ;
if ( ++ __current == __last1 )
return __last1 ;

while ( __predicate ( * __current , * __p ) )
{
if ( ++ __p == __last2 )
return __first1 ;
if ( ++ __current == __last1 )
return __last1 ;
}
++ __first1 ;
}
return __first1 ;
}
#4833
template < typename _ForwardIterator , typename _Integer , typename _Tp >
_ForwardIterator
search_n ( _ForwardIterator __first , _ForwardIterator __last ,
_Integer __count , const _Tp & __val )
{




;

if ( __count <= 0 )
return __first ;
if ( __count == 1 )
return std :: find ( __first , __last , __val ) ;
return std :: __search_n ( __first , __last , __count , __val ,
std :: __iterator_category ( __first ) ) ;
}
#4870
template < typename _ForwardIterator , typename _Integer , typename _Tp ,
typename _BinaryPredicate >
_ForwardIterator
search_n ( _ForwardIterator __first , _ForwardIterator __last ,
_Integer __count , const _Tp & __val ,
_BinaryPredicate __binary_pred )
{




;

if ( __count <= 0 )
return __first ;
if ( __count == 1 )
{
while ( __first != __last && ! bool ( __binary_pred ( * __first , __val ) ) )
++ __first ;
return __first ;
}
return std :: __search_n ( __first , __last , __count , __val , __binary_pred ,
std :: __iterator_category ( __first ) ) ;
}
#4912
template < typename _InputIterator , typename _OutputIterator ,
typename _UnaryOperation >
_OutputIterator
transform ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result , _UnaryOperation __unary_op )
{





;

for ( ; __first != __last ; ++ __first , ++ __result )
* __result = __unary_op ( * __first ) ;
return __result ;
}
#4949
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _BinaryOperation >
_OutputIterator
transform ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _OutputIterator __result ,
_BinaryOperation __binary_op )
{
#4962
;

for ( ; __first1 != __last1 ; ++ __first1 , ++ __first2 , ++ __result )
* __result = __binary_op ( * __first1 , * __first2 ) ;
return __result ;
}
#4982
template < typename _ForwardIterator , typename _Tp >
void
replace ( _ForwardIterator __first , _ForwardIterator __last ,
const _Tp & __old_value , const _Tp & __new_value )
{
#4994
;

for ( ; __first != __last ; ++ __first )
if ( * __first == __old_value )
* __first = __new_value ;
}
#5014
template < typename _ForwardIterator , typename _Predicate , typename _Tp >
void
replace_if ( _ForwardIterator __first , _ForwardIterator __last ,
_Predicate __pred , const _Tp & __new_value )
{
#5026
;

for ( ; __first != __last ; ++ __first )
if ( __pred ( * __first ) )
* __first = __new_value ;
}
#5046
template < typename _ForwardIterator , typename _Generator >
void
generate ( _ForwardIterator __first , _ForwardIterator __last ,
_Generator __gen )
{




;

for ( ; __first != __last ; ++ __first )
* __first = __gen ( ) ;
}
#5077
template < typename _OutputIterator , typename _Size , typename _Generator >
_OutputIterator
generate_n ( _OutputIterator __first , _Size __n , _Generator __gen )
{





for ( __decltype ( __n + 0 ) __niter = __n ;
__niter > 0 ; -- __niter , ++ __first )
* __first = __gen ( ) ;
return __first ;
}
#5114
template < typename _InputIterator , typename _OutputIterator >
inline _OutputIterator
unique_copy ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result )
{
#5125
;

if ( __first == __last )
return __result ;
return std :: __unique_copy ( __first , __last , __result ,
std :: __iterator_category ( __first ) ,
std :: __iterator_category ( __result ) ) ;
}
#5153
template < typename _InputIterator , typename _OutputIterator ,
typename _BinaryPredicate >
inline _OutputIterator
unique_copy ( _InputIterator __first , _InputIterator __last ,
_OutputIterator __result ,
_BinaryPredicate __binary_pred )
{




;

if ( __first == __last )
return __result ;
return std :: __unique_copy ( __first , __last , __result , __binary_pred ,
std :: __iterator_category ( __first ) ,
std :: __iterator_category ( __result ) ) ;
}
#5185
template < typename _RandomAccessIterator >
inline void
random_shuffle ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{



;

if ( __first != __last )
for ( _RandomAccessIterator __i = __first + 1 ; __i != __last ; ++ __i )
std :: iter_swap ( __i , __first + ( std :: rand ( ) % ( ( __i - __first ) + 1 ) ) ) ;
}
#5213
template < typename _RandomAccessIterator , typename _RandomNumberGenerator >
void
random_shuffle ( _RandomAccessIterator __first , _RandomAccessIterator __last ,

_RandomNumberGenerator && __rand )



{



;

if ( __first == __last )
return ;
for ( _RandomAccessIterator __i = __first + 1 ; __i != __last ; ++ __i )
std :: iter_swap ( __i , __first + __rand ( ( __i - __first ) + 1 ) ) ;
}
#5249
template < typename _ForwardIterator , typename _Predicate >
inline _ForwardIterator
partition ( _ForwardIterator __first , _ForwardIterator __last ,
_Predicate __pred )
{





;

return std :: __partition ( __first , __last , __pred ,
std :: __iterator_category ( __first ) ) ;
}
#5283
template < typename _RandomAccessIterator >
inline void
partial_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __middle ,
_RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;





;
;

std :: __heap_select ( __first , __middle , __last ) ;
std :: sort_heap ( __first , __middle ) ;
}
#5322
template < typename _RandomAccessIterator , typename _Compare >
inline void
partial_sort ( _RandomAccessIterator __first ,
_RandomAccessIterator __middle ,
_RandomAccessIterator __last ,
_Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
#5337
;
;

std :: __heap_select ( __first , __middle , __last , __comp ) ;
std :: sort_heap ( __first , __middle , __comp ) ;
}
#5359
template < typename _RandomAccessIterator >
inline void
nth_element ( _RandomAccessIterator __first , _RandomAccessIterator __nth ,
_RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;





;
;

if ( __first == __last || __nth == __last )
return ;

std :: __introselect ( __first , __nth , __last ,
std :: __lg ( __last - __first ) * 2 ) ;
}
#5398
template < typename _RandomAccessIterator , typename _Compare >
inline void
nth_element ( _RandomAccessIterator __first , _RandomAccessIterator __nth ,
_RandomAccessIterator __last , _Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
#5411
;
;

if ( __first == __last || __nth == __last )
return ;

std :: __introselect ( __first , __nth , __last ,
std :: __lg ( __last - __first ) * 2 , __comp ) ;
}
#5436
template < typename _RandomAccessIterator >
inline void
sort ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;





;

if ( __first != __last )
{
std :: __introsort_loop ( __first , __last ,
std :: __lg ( __last - __first ) * 2 ) ;
std :: __final_insertion_sort ( __first , __last ) ;
}
}
#5472
template < typename _RandomAccessIterator , typename _Compare >
inline void
sort ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
#5485
;

if ( __first != __last )
{
std :: __introsort_loop ( __first , __last ,
std :: __lg ( __last - __first ) * 2 , __comp ) ;
std :: __final_insertion_sort ( __first , __last , __comp ) ;
}
}
#5514
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator >
_OutputIterator
merge ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#5534
;
;

while ( __first1 != __last1 && __first2 != __last2 )
{
if ( * __first2 < * __first1 )
{
* __result = * __first2 ;
++ __first2 ;
}
else
{
* __result = * __first1 ;
++ __first1 ;
}
++ __result ;
}
return std :: copy ( __first2 , __last2 , std :: copy ( __first1 , __last1 ,
__result ) ) ;
}
#5578
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _Compare >
_OutputIterator
merge ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result , _Compare __comp )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#5599
;
;

while ( __first1 != __last1 && __first2 != __last2 )
{
if ( __comp ( * __first2 , * __first1 ) )
{
* __result = * __first2 ;
++ __first2 ;
}
else
{
* __result = * __first1 ;
++ __first1 ;
}
++ __result ;
}
return std :: copy ( __first2 , __last2 , std :: copy ( __first1 , __last1 ,
__result ) ) ;
}
#5638
template < typename _RandomAccessIterator >
inline void
stable_sort ( _RandomAccessIterator __first , _RandomAccessIterator __last )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;





;

_Temporary_buffer < _RandomAccessIterator , _ValueType > __buf ( __first ,
__last ) ;
if ( __buf . begin ( ) == 0 )
std :: __inplace_stable_sort ( __first , __last ) ;
else
std :: __stable_sort_adaptive ( __first , __last , __buf . begin ( ) ,
_DistanceType ( __buf . size ( ) ) ) ;
}
#5680
template < typename _RandomAccessIterator , typename _Compare >
inline void
stable_sort ( _RandomAccessIterator __first , _RandomAccessIterator __last ,
_Compare __comp )
{
typedef typename iterator_traits < _RandomAccessIterator > :: value_type
_ValueType ;
typedef typename iterator_traits < _RandomAccessIterator > :: difference_type
_DistanceType ;
#5696
;

_Temporary_buffer < _RandomAccessIterator , _ValueType > __buf ( __first ,
__last ) ;
if ( __buf . begin ( ) == 0 )
std :: __inplace_stable_sort ( __first , __last , __comp ) ;
else
std :: __stable_sort_adaptive ( __first , __last , __buf . begin ( ) ,
_DistanceType ( __buf . size ( ) ) , __comp ) ;
}
#5726
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator >
_OutputIterator
set_union ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#5747
;
;

while ( __first1 != __last1 && __first2 != __last2 )
{
if ( * __first1 < * __first2 )
{
* __result = * __first1 ;
++ __first1 ;
}
else if ( * __first2 < * __first1 )
{
* __result = * __first2 ;
++ __first2 ;
}
else
{
* __result = * __first1 ;
++ __first1 ;
++ __first2 ;
}
++ __result ;
}
return std :: copy ( __first2 , __last2 , std :: copy ( __first1 , __last1 ,
__result ) ) ;
}
#5793
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _Compare >
_OutputIterator
set_union ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result , _Compare __comp )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#5816
;
;

while ( __first1 != __last1 && __first2 != __last2 )
{
if ( __comp ( * __first1 , * __first2 ) )
{
* __result = * __first1 ;
++ __first1 ;
}
else if ( __comp ( * __first2 , * __first1 ) )
{
* __result = * __first2 ;
++ __first2 ;
}
else
{
* __result = * __first1 ;
++ __first1 ;
++ __first2 ;
}
++ __result ;
}
return std :: copy ( __first2 , __last2 , std :: copy ( __first1 , __last1 ,
__result ) ) ;
}
#5860
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator >
_OutputIterator
set_intersection ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#5879
;
;

while ( __first1 != __last1 && __first2 != __last2 )
if ( * __first1 < * __first2 )
++ __first1 ;
else if ( * __first2 < * __first1 )
++ __first2 ;
else
{
* __result = * __first1 ;
++ __first1 ;
++ __first2 ;
++ __result ;
}
return __result ;
}
#5917
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _Compare >
_OutputIterator
set_intersection ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result , _Compare __comp )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#5938
;
;

while ( __first1 != __last1 && __first2 != __last2 )
if ( __comp ( * __first1 , * __first2 ) )
++ __first1 ;
else if ( __comp ( * __first2 , * __first1 ) )
++ __first2 ;
else
{
* __result = * __first1 ;
++ __first1 ;
++ __first2 ;
++ __result ;
}
return __result ;
}
#5975
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator >
_OutputIterator
set_difference ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#5994
;
;

while ( __first1 != __last1 && __first2 != __last2 )
if ( * __first1 < * __first2 )
{
* __result = * __first1 ;
++ __first1 ;
++ __result ;
}
else if ( * __first2 < * __first1 )
++ __first2 ;
else
{
++ __first1 ;
++ __first2 ;
}
return std :: copy ( __first1 , __last1 , __result ) ;
}
#6036
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _Compare >
_OutputIterator
set_difference ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result , _Compare __comp )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#6057
;
;

while ( __first1 != __last1 && __first2 != __last2 )
if ( __comp ( * __first1 , * __first2 ) )
{
* __result = * __first1 ;
++ __first1 ;
++ __result ;
}
else if ( __comp ( * __first2 , * __first1 ) )
++ __first2 ;
else
{
++ __first1 ;
++ __first2 ;
}
return std :: copy ( __first1 , __last1 , __result ) ;
}
#6094
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator >
_OutputIterator
set_symmetric_difference ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#6115
;
;

while ( __first1 != __last1 && __first2 != __last2 )
if ( * __first1 < * __first2 )
{
* __result = * __first1 ;
++ __first1 ;
++ __result ;
}
else if ( * __first2 < * __first1 )
{
* __result = * __first2 ;
++ __first2 ;
++ __result ;
}
else
{
++ __first1 ;
++ __first2 ;
}
return std :: copy ( __first2 , __last2 , std :: copy ( __first1 ,
__last1 , __result ) ) ;
}
#6160
template < typename _InputIterator1 , typename _InputIterator2 ,
typename _OutputIterator , typename _Compare >
_OutputIterator
set_symmetric_difference ( _InputIterator1 __first1 , _InputIterator1 __last1 ,
_InputIterator2 __first2 , _InputIterator2 __last2 ,
_OutputIterator __result ,
_Compare __comp )
{
typedef typename iterator_traits < _InputIterator1 > :: value_type
_ValueType1 ;
typedef typename iterator_traits < _InputIterator2 > :: value_type
_ValueType2 ;
#6184
;
;

while ( __first1 != __last1 && __first2 != __last2 )
if ( __comp ( * __first1 , * __first2 ) )
{
* __result = * __first1 ;
++ __first1 ;
++ __result ;
}
else if ( __comp ( * __first2 , * __first1 ) )
{
* __result = * __first2 ;
++ __first2 ;
++ __result ;
}
else
{
++ __first1 ;
++ __first2 ;
}
return std :: copy ( __first2 , __last2 ,
std :: copy ( __first1 , __last1 , __result ) ) ;
}
#6217
template < typename _ForwardIterator >
_ForwardIterator
min_element ( _ForwardIterator __first , _ForwardIterator __last )
{




;

if ( __first == __last )
return __first ;
_ForwardIterator __result = __first ;
while ( ++ __first != __last )
if ( * __first < * __result )
__result = __first ;
return __result ;
}
#6245
template < typename _ForwardIterator , typename _Compare >
_ForwardIterator
min_element ( _ForwardIterator __first , _ForwardIterator __last ,
_Compare __comp )
{





;

if ( __first == __last )
return __first ;
_ForwardIterator __result = __first ;
while ( ++ __first != __last )
if ( __comp ( * __first , * __result ) )
__result = __first ;
return __result ;
}
#6273
template < typename _ForwardIterator >
_ForwardIterator
max_element ( _ForwardIterator __first , _ForwardIterator __last )
{




;

if ( __first == __last )
return __first ;
_ForwardIterator __result = __first ;
while ( ++ __first != __last )
if ( * __result < * __first )
__result = __first ;
return __result ;
}
#6301
template < typename _ForwardIterator , typename _Compare >
_ForwardIterator
max_element ( _ForwardIterator __first , _ForwardIterator __last ,
_Compare __comp )
{





;

if ( __first == __last ) return __first ;
_ForwardIterator __result = __first ;
while ( ++ __first != __last )
if ( __comp ( * __result , * __first ) )
__result = __first ;
return __result ;
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/map"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_tree.h"
#69
namespace std
{
#89
enum _Rb_tree_color { _S_red = false , _S_black = true } ;

struct _Rb_tree_node_base
{
typedef _Rb_tree_node_base * _Base_ptr ;
typedef const _Rb_tree_node_base * _Const_Base_ptr ;

_Rb_tree_color _M_color ;
_Base_ptr _M_parent ;
_Base_ptr _M_left ;
_Base_ptr _M_right ;

static _Base_ptr
_S_minimum ( _Base_ptr __x )
{
while ( __x -> _M_left != 0 ) __x = __x -> _M_left ;
return __x ;
}

static _Const_Base_ptr
_S_minimum ( _Const_Base_ptr __x )
{
while ( __x -> _M_left != 0 ) __x = __x -> _M_left ;
return __x ;
}

static _Base_ptr
_S_maximum ( _Base_ptr __x )
{
while ( __x -> _M_right != 0 ) __x = __x -> _M_right ;
return __x ;
}

static _Const_Base_ptr
_S_maximum ( _Const_Base_ptr __x )
{
while ( __x -> _M_right != 0 ) __x = __x -> _M_right ;
return __x ;
}
} ;

template < typename _Val >
struct _Rb_tree_node : public _Rb_tree_node_base
{
typedef _Rb_tree_node < _Val > * _Link_type ;
_Val _M_value_field ;


template < typename ... _Args >
_Rb_tree_node ( _Args && ... __args )
: _Rb_tree_node_base ( ) ,
_M_value_field ( std :: forward < _Args > ( __args ) ... ) { }

} ;

__attribute__ ( ( __pure__ ) ) _Rb_tree_node_base *
_Rb_tree_increment ( _Rb_tree_node_base * __x ) throw ( ) ;

__attribute__ ( ( __pure__ ) ) const _Rb_tree_node_base *
_Rb_tree_increment ( const _Rb_tree_node_base * __x ) throw ( ) ;

__attribute__ ( ( __pure__ ) ) _Rb_tree_node_base *
_Rb_tree_decrement ( _Rb_tree_node_base * __x ) throw ( ) ;

__attribute__ ( ( __pure__ ) ) const _Rb_tree_node_base *
_Rb_tree_decrement ( const _Rb_tree_node_base * __x ) throw ( ) ;

template < typename _Tp >
struct _Rb_tree_iterator
{
typedef _Tp value_type ;
typedef _Tp & reference ;
typedef _Tp * pointer ;

typedef bidirectional_iterator_tag iterator_category ;
typedef ptrdiff_t difference_type ;

typedef _Rb_tree_iterator < _Tp > _Self ;
typedef _Rb_tree_node_base :: _Base_ptr _Base_ptr ;
typedef _Rb_tree_node < _Tp > * _Link_type ;

_Rb_tree_iterator ( )
: _M_node ( ) { }

explicit
_Rb_tree_iterator ( _Link_type __x )
: _M_node ( __x ) { }

reference
operator * ( ) const
{ return static_cast < _Link_type > ( _M_node ) -> _M_value_field ; }

pointer
operator -> ( ) const
{ return std :: __addressof ( static_cast < _Link_type >
( _M_node ) -> _M_value_field ) ; }

_Self &
operator ++ ( )
{
_M_node = _Rb_tree_increment ( _M_node ) ;
return * this ;
}

_Self
operator ++ ( int )
{
_Self __tmp = * this ;
_M_node = _Rb_tree_increment ( _M_node ) ;
return __tmp ;
}

_Self &
operator -- ( )
{
_M_node = _Rb_tree_decrement ( _M_node ) ;
return * this ;
}

_Self
operator -- ( int )
{
_Self __tmp = * this ;
_M_node = _Rb_tree_decrement ( _M_node ) ;
return __tmp ;
}

bool
operator == ( const _Self & __x ) const
{ return _M_node == __x . _M_node ; }

bool
operator != ( const _Self & __x ) const
{ return _M_node != __x . _M_node ; }

_Base_ptr _M_node ;
} ;

template < typename _Tp >
struct _Rb_tree_const_iterator
{
typedef _Tp value_type ;
typedef const _Tp & reference ;
typedef const _Tp * pointer ;

typedef _Rb_tree_iterator < _Tp > iterator ;

typedef bidirectional_iterator_tag iterator_category ;
typedef ptrdiff_t difference_type ;

typedef _Rb_tree_const_iterator < _Tp > _Self ;
typedef _Rb_tree_node_base :: _Const_Base_ptr _Base_ptr ;
typedef const _Rb_tree_node < _Tp > * _Link_type ;

_Rb_tree_const_iterator ( )
: _M_node ( ) { }

explicit
_Rb_tree_const_iterator ( _Link_type __x )
: _M_node ( __x ) { }

_Rb_tree_const_iterator ( const iterator & __it )
: _M_node ( __it . _M_node ) { }

iterator
_M_const_cast ( ) const
{ return iterator ( static_cast < typename iterator :: _Link_type >
( const_cast < typename iterator :: _Base_ptr > ( _M_node ) ) ) ; }

reference
operator * ( ) const
{ return static_cast < _Link_type > ( _M_node ) -> _M_value_field ; }

pointer
operator -> ( ) const
{ return std :: __addressof ( static_cast < _Link_type >
( _M_node ) -> _M_value_field ) ; }

_Self &
operator ++ ( )
{
_M_node = _Rb_tree_increment ( _M_node ) ;
return * this ;
}

_Self
operator ++ ( int )
{
_Self __tmp = * this ;
_M_node = _Rb_tree_increment ( _M_node ) ;
return __tmp ;
}

_Self &
operator -- ( )
{
_M_node = _Rb_tree_decrement ( _M_node ) ;
return * this ;
}

_Self
operator -- ( int )
{
_Self __tmp = * this ;
_M_node = _Rb_tree_decrement ( _M_node ) ;
return __tmp ;
}

bool
operator == ( const _Self & __x ) const
{ return _M_node == __x . _M_node ; }

bool
operator != ( const _Self & __x ) const
{ return _M_node != __x . _M_node ; }

_Base_ptr _M_node ;
} ;

template < typename _Val >
inline bool
operator == ( const _Rb_tree_iterator < _Val > & __x ,
const _Rb_tree_const_iterator < _Val > & __y )
{ return __x . _M_node == __y . _M_node ; }

template < typename _Val >
inline bool
operator != ( const _Rb_tree_iterator < _Val > & __x ,
const _Rb_tree_const_iterator < _Val > & __y )
{ return __x . _M_node != __y . _M_node ; }

void
_Rb_tree_insert_and_rebalance ( const bool __insert_left ,
_Rb_tree_node_base * __x ,
_Rb_tree_node_base * __p ,
_Rb_tree_node_base & __header ) throw ( ) ;

_Rb_tree_node_base *
_Rb_tree_rebalance_for_erase ( _Rb_tree_node_base * const __z ,
_Rb_tree_node_base & __header ) throw ( ) ;


template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc = allocator < _Val > >
class _Rb_tree
{
typedef typename _Alloc :: template rebind < _Rb_tree_node < _Val > > :: other
_Node_allocator ;

protected :
typedef _Rb_tree_node_base * _Base_ptr ;
typedef const _Rb_tree_node_base * _Const_Base_ptr ;

public :
typedef _Key key_type ;
typedef _Val value_type ;
typedef value_type * pointer ;
typedef const value_type * const_pointer ;
typedef value_type & reference ;
typedef const value_type & const_reference ;
typedef _Rb_tree_node < _Val > * _Link_type ;
typedef const _Rb_tree_node < _Val > * _Const_Link_type ;
typedef size_t size_type ;
typedef ptrdiff_t difference_type ;
typedef _Alloc allocator_type ;

_Node_allocator &
_M_get_Node_allocator ( ) noexcept
{ return * static_cast < _Node_allocator * > ( & this -> _M_impl ) ; }

const _Node_allocator &
_M_get_Node_allocator ( ) const noexcept
{ return * static_cast < const _Node_allocator * > ( & this -> _M_impl ) ; }

allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_get_Node_allocator ( ) ) ; }

protected :
_Link_type
_M_get_node ( )
{ return _M_impl . _Node_allocator :: allocate ( 1 ) ; }

void
_M_put_node ( _Link_type __p )
{ _M_impl . _Node_allocator :: deallocate ( __p , 1 ) ; }
#399
template < typename ... _Args >
_Link_type
_M_create_node ( _Args && ... __args )
{
_Link_type __tmp = _M_get_node ( ) ;
try
{
allocator_traits < _Node_allocator > ::
construct ( _M_get_Node_allocator ( ) , __tmp ,
std :: forward < _Args > ( __args ) ... ) ;
}
catch ( ... )
{
_M_put_node ( __tmp ) ;
throw ;
}
return __tmp ;
}

void
_M_destroy_node ( _Link_type __p )
{
_M_get_Node_allocator ( ) . destroy ( __p ) ;
_M_put_node ( __p ) ;
}


_Link_type
_M_clone_node ( _Const_Link_type __x )
{
_Link_type __tmp = _M_create_node ( __x -> _M_value_field ) ;
__tmp -> _M_color = __x -> _M_color ;
__tmp -> _M_left = 0 ;
__tmp -> _M_right = 0 ;
return __tmp ;
}

protected :
template < typename _Key_compare ,
bool _Is_pod_comparator = __oracle_is_pod ( _Key_compare ) >
struct _Rb_tree_impl : public _Node_allocator
{
_Key_compare _M_key_compare ;
_Rb_tree_node_base _M_header ;
size_type _M_node_count ;

_Rb_tree_impl ( )
: _Node_allocator ( ) , _M_key_compare ( ) , _M_header ( ) ,
_M_node_count ( 0 )
{ _M_initialize ( ) ; }

_Rb_tree_impl ( const _Key_compare & __comp , const _Node_allocator & __a )
: _Node_allocator ( __a ) , _M_key_compare ( __comp ) , _M_header ( ) ,
_M_node_count ( 0 )
{ _M_initialize ( ) ; }


_Rb_tree_impl ( const _Key_compare & __comp , _Node_allocator && __a )
: _Node_allocator ( std :: move ( __a ) ) , _M_key_compare ( __comp ) ,
_M_header ( ) , _M_node_count ( 0 )
{ _M_initialize ( ) ; }


private :
void
_M_initialize ( )
{
this -> _M_header . _M_color = _S_red ;
this -> _M_header . _M_parent = 0 ;
this -> _M_header . _M_left = & this -> _M_header ;
this -> _M_header . _M_right = & this -> _M_header ;
}
} ;

_Rb_tree_impl < _Compare > _M_impl ;

protected :
_Base_ptr &
_M_root ( )
{ return this -> _M_impl . _M_header . _M_parent ; }

_Const_Base_ptr
_M_root ( ) const
{ return this -> _M_impl . _M_header . _M_parent ; }

_Base_ptr &
_M_leftmost ( )
{ return this -> _M_impl . _M_header . _M_left ; }

_Const_Base_ptr
_M_leftmost ( ) const
{ return this -> _M_impl . _M_header . _M_left ; }

_Base_ptr &
_M_rightmost ( )
{ return this -> _M_impl . _M_header . _M_right ; }

_Const_Base_ptr
_M_rightmost ( ) const
{ return this -> _M_impl . _M_header . _M_right ; }

_Link_type
_M_begin ( )
{ return static_cast < _Link_type > ( this -> _M_impl . _M_header . _M_parent ) ; }

_Const_Link_type
_M_begin ( ) const
{
return static_cast < _Const_Link_type >
( this -> _M_impl . _M_header . _M_parent ) ;
}

_Link_type
_M_end ( )
{ return static_cast < _Link_type > ( & this -> _M_impl . _M_header ) ; }

_Const_Link_type
_M_end ( ) const
{ return static_cast < _Const_Link_type > ( & this -> _M_impl . _M_header ) ; }

static const_reference
_S_value ( _Const_Link_type __x )
{ return __x -> _M_value_field ; }

static const _Key &
_S_key ( _Const_Link_type __x )
{ return _KeyOfValue ( ) ( _S_value ( __x ) ) ; }

static _Link_type
_S_left ( _Base_ptr __x )
{ return static_cast < _Link_type > ( __x -> _M_left ) ; }

static _Const_Link_type
_S_left ( _Const_Base_ptr __x )
{ return static_cast < _Const_Link_type > ( __x -> _M_left ) ; }

static _Link_type
_S_right ( _Base_ptr __x )
{ return static_cast < _Link_type > ( __x -> _M_right ) ; }

static _Const_Link_type
_S_right ( _Const_Base_ptr __x )
{ return static_cast < _Const_Link_type > ( __x -> _M_right ) ; }

static const_reference
_S_value ( _Const_Base_ptr __x )
{ return static_cast < _Const_Link_type > ( __x ) -> _M_value_field ; }

static const _Key &
_S_key ( _Const_Base_ptr __x )
{ return _KeyOfValue ( ) ( _S_value ( __x ) ) ; }

static _Base_ptr
_S_minimum ( _Base_ptr __x )
{ return _Rb_tree_node_base :: _S_minimum ( __x ) ; }

static _Const_Base_ptr
_S_minimum ( _Const_Base_ptr __x )
{ return _Rb_tree_node_base :: _S_minimum ( __x ) ; }

static _Base_ptr
_S_maximum ( _Base_ptr __x )
{ return _Rb_tree_node_base :: _S_maximum ( __x ) ; }

static _Const_Base_ptr
_S_maximum ( _Const_Base_ptr __x )
{ return _Rb_tree_node_base :: _S_maximum ( __x ) ; }

public :
typedef _Rb_tree_iterator < value_type > iterator ;
typedef _Rb_tree_const_iterator < value_type > const_iterator ;

typedef std :: reverse_iterator < iterator > reverse_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;

private :
pair < _Base_ptr , _Base_ptr >
_M_get_insert_unique_pos ( const key_type & __k ) ;

pair < _Base_ptr , _Base_ptr >
_M_get_insert_equal_pos ( const key_type & __k ) ;

pair < _Base_ptr , _Base_ptr >
_M_get_insert_hint_unique_pos ( const_iterator __pos ,
const key_type & __k ) ;

pair < _Base_ptr , _Base_ptr >
_M_get_insert_hint_equal_pos ( const_iterator __pos ,
const key_type & __k ) ;


template < typename _Arg >
iterator
_M_insert_ ( _Base_ptr __x , _Base_ptr __y , _Arg && __v ) ;

iterator
_M_insert_node ( _Base_ptr __x , _Base_ptr __y , _Link_type __z ) ;

template < typename _Arg >
iterator
_M_insert_lower ( _Base_ptr __y , _Arg && __v ) ;

template < typename _Arg >
iterator
_M_insert_equal_lower ( _Arg && __x ) ;

iterator
_M_insert_lower_node ( _Base_ptr __p , _Link_type __z ) ;

iterator
_M_insert_equal_lower_node ( _Link_type __z ) ;
#624
_Link_type
_M_copy ( _Const_Link_type __x , _Link_type __p ) ;

void
_M_erase ( _Link_type __x ) ;

iterator
_M_lower_bound ( _Link_type __x , _Link_type __y ,
const _Key & __k ) ;

const_iterator
_M_lower_bound ( _Const_Link_type __x , _Const_Link_type __y ,
const _Key & __k ) const ;

iterator
_M_upper_bound ( _Link_type __x , _Link_type __y ,
const _Key & __k ) ;

const_iterator
_M_upper_bound ( _Const_Link_type __x , _Const_Link_type __y ,
const _Key & __k ) const ;

public :

_Rb_tree ( ) { }

_Rb_tree ( const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_impl ( __comp , _Node_allocator ( __a ) ) { }

_Rb_tree ( const _Rb_tree & __x )
: _M_impl ( __x . _M_impl . _M_key_compare , __x . _M_get_Node_allocator ( ) )
{
if ( __x . _M_root ( ) != 0 )
{
_M_root ( ) = _M_copy ( __x . _M_begin ( ) , _M_end ( ) ) ;
_M_leftmost ( ) = _S_minimum ( _M_root ( ) ) ;
_M_rightmost ( ) = _S_maximum ( _M_root ( ) ) ;
_M_impl . _M_node_count = __x . _M_impl . _M_node_count ;
}
}


_Rb_tree ( _Rb_tree && __x ) ;


~ _Rb_tree ( ) noexcept
{ _M_erase ( _M_begin ( ) ) ; }

_Rb_tree &
operator = ( const _Rb_tree & __x ) ;


_Compare
key_comp ( ) const
{ return _M_impl . _M_key_compare ; }

iterator
begin ( ) noexcept
{
return iterator ( static_cast < _Link_type >
( this -> _M_impl . _M_header . _M_left ) ) ;
}

const_iterator
begin ( ) const noexcept
{
return const_iterator ( static_cast < _Const_Link_type >
( this -> _M_impl . _M_header . _M_left ) ) ;
}

iterator
end ( ) noexcept
{ return iterator ( static_cast < _Link_type > ( & this -> _M_impl . _M_header ) ) ; }

const_iterator
end ( ) const noexcept
{
return const_iterator ( static_cast < _Const_Link_type >
( & this -> _M_impl . _M_header ) ) ;
}

reverse_iterator
rbegin ( ) noexcept
{ return reverse_iterator ( end ( ) ) ; }

const_reverse_iterator
rbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }

reverse_iterator
rend ( ) noexcept
{ return reverse_iterator ( begin ( ) ) ; }

const_reverse_iterator
rend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }

bool
empty ( ) const noexcept
{ return _M_impl . _M_node_count == 0 ; }

size_type
size ( ) const noexcept
{ return _M_impl . _M_node_count ; }

size_type
max_size ( ) const noexcept
{ return _M_get_Node_allocator ( ) . max_size ( ) ; }

void
swap ( _Rb_tree & __t ) ;



template < typename _Arg >
pair < iterator , bool >
_M_insert_unique ( _Arg && __x ) ;

template < typename _Arg >
iterator
_M_insert_equal ( _Arg && __x ) ;

template < typename _Arg >
iterator
_M_insert_unique_ ( const_iterator __position , _Arg && __x ) ;

template < typename _Arg >
iterator
_M_insert_equal_ ( const_iterator __position , _Arg && __x ) ;

template < typename ... _Args >
pair < iterator , bool >
_M_emplace_unique ( _Args && ... __args ) ;

template < typename ... _Args >
iterator
_M_emplace_equal ( _Args && ... __args ) ;

template < typename ... _Args >
iterator
_M_emplace_hint_unique ( const_iterator __pos , _Args && ... __args ) ;

template < typename ... _Args >
iterator
_M_emplace_hint_equal ( const_iterator __pos , _Args && ... __args ) ;
#784
template < typename _InputIterator >
void
_M_insert_unique ( _InputIterator __first , _InputIterator __last ) ;

template < typename _InputIterator >
void
_M_insert_equal ( _InputIterator __first , _InputIterator __last ) ;

private :
void
_M_erase_aux ( const_iterator __position ) ;

void
_M_erase_aux ( const_iterator __first , const_iterator __last ) ;

public :



__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( const_iterator __position )
{
const_iterator __result = __position ;
++ __result ;
_M_erase_aux ( __position ) ;
return __result . _M_const_cast ( ) ;
}


__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( iterator __position )
{
iterator __result = __position ;
++ __result ;
_M_erase_aux ( __position ) ;
return __result ;
}
#832
size_type
erase ( const key_type & __x ) ;




__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( const_iterator __first , const_iterator __last )
{
_M_erase_aux ( __first , __last ) ;
return __last . _M_const_cast ( ) ;
}
#854
void
erase ( const key_type * __first , const key_type * __last ) ;

void
clear ( ) noexcept
{
_M_erase ( _M_begin ( ) ) ;
_M_leftmost ( ) = _M_end ( ) ;
_M_root ( ) = 0 ;
_M_rightmost ( ) = _M_end ( ) ;
_M_impl . _M_node_count = 0 ;
}


iterator
find ( const key_type & __k ) ;

const_iterator
find ( const key_type & __k ) const ;

size_type
count ( const key_type & __k ) const ;

iterator
lower_bound ( const key_type & __k )
{ return _M_lower_bound ( _M_begin ( ) , _M_end ( ) , __k ) ; }

const_iterator
lower_bound ( const key_type & __k ) const
{ return _M_lower_bound ( _M_begin ( ) , _M_end ( ) , __k ) ; }

iterator
upper_bound ( const key_type & __k )
{ return _M_upper_bound ( _M_begin ( ) , _M_end ( ) , __k ) ; }

const_iterator
upper_bound ( const key_type & __k ) const
{ return _M_upper_bound ( _M_begin ( ) , _M_end ( ) , __k ) ; }

pair < iterator , iterator >
equal_range ( const key_type & __k ) ;

pair < const_iterator , const_iterator >
equal_range ( const key_type & __k ) const ;


bool
__rb_verify ( ) const ;
} ;

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
inline bool
operator == ( const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x ,
const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __y )
{
return __x . size ( ) == __y . size ( )
&& std :: equal ( __x . begin ( ) , __x . end ( ) , __y . begin ( ) ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
inline bool
operator < ( const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x ,
const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __y )
{
return std :: lexicographical_compare ( __x . begin ( ) , __x . end ( ) ,
__y . begin ( ) , __y . end ( ) ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
inline bool
operator != ( const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x ,
const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __y )
{ return ! ( __x == __y ) ; }

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
inline bool
operator > ( const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x ,
const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __y )
{ return __y < __x ; }

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
inline bool
operator <= ( const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x ,
const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __y )
{ return ! ( __y < __x ) ; }

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
inline bool
operator >= ( const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x ,
const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __y )
{ return ! ( __x < __y ) ; }

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
inline void
swap ( _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x ,
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __y )
{ __x . swap ( __y ) ; }


template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_Rb_tree ( _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > && __x )
: _M_impl ( __x . _M_impl . _M_key_compare ,
std :: move ( __x . _M_get_Node_allocator ( ) ) )
{
if ( __x . _M_root ( ) != 0 )
{
_M_root ( ) = __x . _M_root ( ) ;
_M_leftmost ( ) = __x . _M_leftmost ( ) ;
_M_rightmost ( ) = __x . _M_rightmost ( ) ;
_M_root ( ) -> _M_parent = _M_end ( ) ;

__x . _M_root ( ) = 0 ;
__x . _M_leftmost ( ) = __x . _M_end ( ) ;
__x . _M_rightmost ( ) = __x . _M_end ( ) ;

this -> _M_impl . _M_node_count = __x . _M_impl . _M_node_count ;
__x . _M_impl . _M_node_count = 0 ;
}
}


template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > &
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
operator = ( const _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __x )
{
if ( this != & __x )
{

clear ( ) ;
_M_impl . _M_key_compare = __x . _M_impl . _M_key_compare ;
if ( __x . _M_root ( ) != 0 )
{
_M_root ( ) = _M_copy ( __x . _M_begin ( ) , _M_end ( ) ) ;
_M_leftmost ( ) = _S_minimum ( _M_root ( ) ) ;
_M_rightmost ( ) = _S_maximum ( _M_root ( ) ) ;
_M_impl . _M_node_count = __x . _M_impl . _M_node_count ;
}
}
return * this ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >

template < typename _Arg >

typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::

_M_insert_ ( _Base_ptr __x , _Base_ptr __p , _Arg && __v )



{
bool __insert_left = ( __x != 0 || __p == _M_end ( )
|| _M_impl . _M_key_compare ( _KeyOfValue ( ) ( __v ) ,
_S_key ( __p ) ) ) ;

_Link_type __z = _M_create_node ( std :: forward < _Arg > ( __v ) ) ;

_Rb_tree_insert_and_rebalance ( __insert_left , __z , __p ,
this -> _M_impl . _M_header ) ;
++ _M_impl . _M_node_count ;
return iterator ( __z ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >

template < typename _Arg >

typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::

_M_insert_lower ( _Base_ptr __p , _Arg && __v )



{
bool __insert_left = ( __p == _M_end ( )
|| ! _M_impl . _M_key_compare ( _S_key ( __p ) ,
_KeyOfValue ( ) ( __v ) ) ) ;

_Link_type __z = _M_create_node ( std :: forward < _Arg > ( __v ) ) ;

_Rb_tree_insert_and_rebalance ( __insert_left , __z , __p ,
this -> _M_impl . _M_header ) ;
++ _M_impl . _M_node_count ;
return iterator ( __z ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >

template < typename _Arg >

typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::

_M_insert_equal_lower ( _Arg && __v )



{
_Link_type __x = _M_begin ( ) ;
_Link_type __y = _M_end ( ) ;
while ( __x != 0 )
{
__y = __x ;
__x = ! _M_impl . _M_key_compare ( _S_key ( __x ) , _KeyOfValue ( ) ( __v ) ) ?
_S_left ( __x ) : _S_right ( __x ) ;
}
return _M_insert_lower ( __y , std :: forward < _Arg > ( __v ) ) ;
}

template < typename _Key , typename _Val , typename _KoV ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KoV , _Compare , _Alloc > :: _Link_type
_Rb_tree < _Key , _Val , _KoV , _Compare , _Alloc > ::
_M_copy ( _Const_Link_type __x , _Link_type __p )
{

_Link_type __top = _M_clone_node ( __x ) ;
__top -> _M_parent = __p ;

try
{
if ( __x -> _M_right )
__top -> _M_right = _M_copy ( _S_right ( __x ) , __top ) ;
__p = __top ;
__x = _S_left ( __x ) ;

while ( __x != 0 )
{
_Link_type __y = _M_clone_node ( __x ) ;
__p -> _M_left = __y ;
__y -> _M_parent = __p ;
if ( __x -> _M_right )
__y -> _M_right = _M_copy ( _S_right ( __x ) , __y ) ;
__p = __y ;
__x = _S_left ( __x ) ;
}
}
catch ( ... )
{
_M_erase ( __top ) ;
throw ;
}
return __top ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
void
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_erase ( _Link_type __x )
{

while ( __x != 0 )
{
_M_erase ( _S_right ( __x ) ) ;
_Link_type __y = _S_left ( __x ) ;
_M_destroy_node ( __x ) ;
__x = __y ;
}
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_lower_bound ( _Link_type __x , _Link_type __y ,
const _Key & __k )
{
while ( __x != 0 )
if ( ! _M_impl . _M_key_compare ( _S_key ( __x ) , __k ) )
__y = __x , __x = _S_left ( __x ) ;
else
__x = _S_right ( __x ) ;
return iterator ( __y ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: const_iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_lower_bound ( _Const_Link_type __x , _Const_Link_type __y ,
const _Key & __k ) const
{
while ( __x != 0 )
if ( ! _M_impl . _M_key_compare ( _S_key ( __x ) , __k ) )
__y = __x , __x = _S_left ( __x ) ;
else
__x = _S_right ( __x ) ;
return const_iterator ( __y ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_upper_bound ( _Link_type __x , _Link_type __y ,
const _Key & __k )
{
while ( __x != 0 )
if ( _M_impl . _M_key_compare ( __k , _S_key ( __x ) ) )
__y = __x , __x = _S_left ( __x ) ;
else
__x = _S_right ( __x ) ;
return iterator ( __y ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: const_iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_upper_bound ( _Const_Link_type __x , _Const_Link_type __y ,
const _Key & __k ) const
{
while ( __x != 0 )
if ( _M_impl . _M_key_compare ( __k , _S_key ( __x ) ) )
__y = __x , __x = _S_left ( __x ) ;
else
__x = _S_right ( __x ) ;
return const_iterator ( __y ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: iterator ,
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: iterator >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
equal_range ( const _Key & __k )
{
_Link_type __x = _M_begin ( ) ;
_Link_type __y = _M_end ( ) ;
while ( __x != 0 )
{
if ( _M_impl . _M_key_compare ( _S_key ( __x ) , __k ) )
__x = _S_right ( __x ) ;
else if ( _M_impl . _M_key_compare ( __k , _S_key ( __x ) ) )
__y = __x , __x = _S_left ( __x ) ;
else
{
_Link_type __xu ( __x ) , __yu ( __y ) ;
__y = __x , __x = _S_left ( __x ) ;
__xu = _S_right ( __xu ) ;
return pair < iterator ,
iterator > ( _M_lower_bound ( __x , __y , __k ) ,
_M_upper_bound ( __xu , __yu , __k ) ) ;
}
}
return pair < iterator , iterator > ( iterator ( __y ) ,
iterator ( __y ) ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: const_iterator ,
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: const_iterator >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
equal_range ( const _Key & __k ) const
{
_Const_Link_type __x = _M_begin ( ) ;
_Const_Link_type __y = _M_end ( ) ;
while ( __x != 0 )
{
if ( _M_impl . _M_key_compare ( _S_key ( __x ) , __k ) )
__x = _S_right ( __x ) ;
else if ( _M_impl . _M_key_compare ( __k , _S_key ( __x ) ) )
__y = __x , __x = _S_left ( __x ) ;
else
{
_Const_Link_type __xu ( __x ) , __yu ( __y ) ;
__y = __x , __x = _S_left ( __x ) ;
__xu = _S_right ( __xu ) ;
return pair < const_iterator ,
const_iterator > ( _M_lower_bound ( __x , __y , __k ) ,
_M_upper_bound ( __xu , __yu , __k ) ) ;
}
}
return pair < const_iterator , const_iterator > ( const_iterator ( __y ) ,
const_iterator ( __y ) ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
void
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
swap ( _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > & __t )
{
if ( _M_root ( ) == 0 )
{
if ( __t . _M_root ( ) != 0 )
{
_M_root ( ) = __t . _M_root ( ) ;
_M_leftmost ( ) = __t . _M_leftmost ( ) ;
_M_rightmost ( ) = __t . _M_rightmost ( ) ;
_M_root ( ) -> _M_parent = _M_end ( ) ;

__t . _M_root ( ) = 0 ;
__t . _M_leftmost ( ) = __t . _M_end ( ) ;
__t . _M_rightmost ( ) = __t . _M_end ( ) ;
}
}
else if ( __t . _M_root ( ) == 0 )
{
__t . _M_root ( ) = _M_root ( ) ;
__t . _M_leftmost ( ) = _M_leftmost ( ) ;
__t . _M_rightmost ( ) = _M_rightmost ( ) ;
__t . _M_root ( ) -> _M_parent = __t . _M_end ( ) ;

_M_root ( ) = 0 ;
_M_leftmost ( ) = _M_end ( ) ;
_M_rightmost ( ) = _M_end ( ) ;
}
else
{
std :: swap ( _M_root ( ) , __t . _M_root ( ) ) ;
std :: swap ( _M_leftmost ( ) , __t . _M_leftmost ( ) ) ;
std :: swap ( _M_rightmost ( ) , __t . _M_rightmost ( ) ) ;

_M_root ( ) -> _M_parent = _M_end ( ) ;
__t . _M_root ( ) -> _M_parent = __t . _M_end ( ) ;
}

std :: swap ( this -> _M_impl . _M_node_count , __t . _M_impl . _M_node_count ) ;
std :: swap ( this -> _M_impl . _M_key_compare , __t . _M_impl . _M_key_compare ) ;



std :: __alloc_swap < _Node_allocator > ::
_S_do_it ( _M_get_Node_allocator ( ) , __t . _M_get_Node_allocator ( ) ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr ,
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_get_insert_unique_pos ( const key_type & __k )
{
typedef pair < _Base_ptr , _Base_ptr > _Res ;
_Link_type __x = _M_begin ( ) ;
_Link_type __y = _M_end ( ) ;
bool __comp = true ;
while ( __x != 0 )
{
__y = __x ;
__comp = _M_impl . _M_key_compare ( __k , _S_key ( __x ) ) ;
__x = __comp ? _S_left ( __x ) : _S_right ( __x ) ;
}
iterator __j = iterator ( __y ) ;
if ( __comp )
{
if ( __j == begin ( ) )
return _Res ( __x , __y ) ;
else
-- __j ;
}
if ( _M_impl . _M_key_compare ( _S_key ( __j . _M_node ) , __k ) )
return _Res ( __x , __y ) ;
return _Res ( __j . _M_node , 0 ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr ,
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_get_insert_equal_pos ( const key_type & __k )
{
typedef pair < _Base_ptr , _Base_ptr > _Res ;
_Link_type __x = _M_begin ( ) ;
_Link_type __y = _M_end ( ) ;
while ( __x != 0 )
{
__y = __x ;
__x = _M_impl . _M_key_compare ( __k , _S_key ( __x ) ) ?
_S_left ( __x ) : _S_right ( __x ) ;
}
return _Res ( __x , __y ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >

template < typename _Arg >

pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: iterator , bool >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::

_M_insert_unique ( _Arg && __v )



{
typedef pair < iterator , bool > _Res ;
pair < _Base_ptr , _Base_ptr > __res
= _M_get_insert_unique_pos ( _KeyOfValue ( ) ( __v ) ) ;

if ( __res . second )
return _Res ( _M_insert_ ( __res . first , __res . second ,
std :: forward < _Arg > ( __v ) ) ,
true ) ;

return _Res ( iterator ( static_cast < _Link_type > ( __res . first ) ) , false ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >

template < typename _Arg >

typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::

_M_insert_equal ( _Arg && __v )



{
pair < _Base_ptr , _Base_ptr > __res
= _M_get_insert_equal_pos ( _KeyOfValue ( ) ( __v ) ) ;
return _M_insert_ ( __res . first , __res . second , std :: forward < _Arg > ( __v ) ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr ,
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_get_insert_hint_unique_pos ( const_iterator __position ,
const key_type & __k )
{
iterator __pos = __position . _M_const_cast ( ) ;
typedef pair < _Base_ptr , _Base_ptr > _Res ;


if ( __pos . _M_node == _M_end ( ) )
{
if ( size ( ) > 0
&& _M_impl . _M_key_compare ( _S_key ( _M_rightmost ( ) ) , __k ) )
return _Res ( 0 , _M_rightmost ( ) ) ;
else
return _M_get_insert_unique_pos ( __k ) ;
}
else if ( _M_impl . _M_key_compare ( __k , _S_key ( __pos . _M_node ) ) )
{

iterator __before = __pos ;
if ( __pos . _M_node == _M_leftmost ( ) )
return _Res ( _M_leftmost ( ) , _M_leftmost ( ) ) ;
else if ( _M_impl . _M_key_compare ( _S_key ( ( -- __before ) . _M_node ) , __k ) )
{
if ( _S_right ( __before . _M_node ) == 0 )
return _Res ( 0 , __before . _M_node ) ;
else
return _Res ( __pos . _M_node , __pos . _M_node ) ;
}
else
return _M_get_insert_unique_pos ( __k ) ;
}
else if ( _M_impl . _M_key_compare ( _S_key ( __pos . _M_node ) , __k ) )
{

iterator __after = __pos ;
if ( __pos . _M_node == _M_rightmost ( ) )
return _Res ( 0 , _M_rightmost ( ) ) ;
else if ( _M_impl . _M_key_compare ( __k , _S_key ( ( ++ __after ) . _M_node ) ) )
{
if ( _S_right ( __pos . _M_node ) == 0 )
return _Res ( 0 , __pos . _M_node ) ;
else
return _Res ( __after . _M_node , __after . _M_node ) ;
}
else
return _M_get_insert_unique_pos ( __k ) ;
}
else

return _Res ( __pos . _M_node , 0 ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >

template < typename _Arg >

typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::

_M_insert_unique_ ( const_iterator __position , _Arg && __v )



{
pair < _Base_ptr , _Base_ptr > __res
= _M_get_insert_hint_unique_pos ( __position , _KeyOfValue ( ) ( __v ) ) ;

if ( __res . second )
return _M_insert_ ( __res . first , __res . second ,
std :: forward < _Arg > ( __v ) ) ;
return iterator ( static_cast < _Link_type > ( __res . first ) ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr ,
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: _Base_ptr >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_get_insert_hint_equal_pos ( const_iterator __position , const key_type & __k )
{
iterator __pos = __position . _M_const_cast ( ) ;
typedef pair < _Base_ptr , _Base_ptr > _Res ;


if ( __pos . _M_node == _M_end ( ) )
{
if ( size ( ) > 0
&& ! _M_impl . _M_key_compare ( __k , _S_key ( _M_rightmost ( ) ) ) )
return _Res ( 0 , _M_rightmost ( ) ) ;
else
return _M_get_insert_equal_pos ( __k ) ;
}
else if ( ! _M_impl . _M_key_compare ( _S_key ( __pos . _M_node ) , __k ) )
{

iterator __before = __pos ;
if ( __pos . _M_node == _M_leftmost ( ) )
return _Res ( _M_leftmost ( ) , _M_leftmost ( ) ) ;
else if ( ! _M_impl . _M_key_compare ( __k , _S_key ( ( -- __before ) . _M_node ) ) )
{
if ( _S_right ( __before . _M_node ) == 0 )
return _Res ( 0 , __before . _M_node ) ;
else
return _Res ( __pos . _M_node , __pos . _M_node ) ;
}
else
return _M_get_insert_equal_pos ( __k ) ;
}
else
{

iterator __after = __pos ;
if ( __pos . _M_node == _M_rightmost ( ) )
return _Res ( 0 , _M_rightmost ( ) ) ;
else if ( ! _M_impl . _M_key_compare ( _S_key ( ( ++ __after ) . _M_node ) , __k ) )
{
if ( _S_right ( __pos . _M_node ) == 0 )
return _Res ( 0 , __pos . _M_node ) ;
else
return _Res ( __after . _M_node , __after . _M_node ) ;
}
else
return _Res ( 0 , 0 ) ;
}
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >

template < typename _Arg >

typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::

_M_insert_equal_ ( const_iterator __position , _Arg && __v )



{
pair < _Base_ptr , _Base_ptr > __res
= _M_get_insert_hint_equal_pos ( __position , _KeyOfValue ( ) ( __v ) ) ;

if ( __res . second )
return _M_insert_ ( __res . first , __res . second ,
std :: forward < _Arg > ( __v ) ) ;

return _M_insert_equal_lower ( std :: forward < _Arg > ( __v ) ) ;
}


template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_insert_node ( _Base_ptr __x , _Base_ptr __p , _Link_type __z )
{
bool __insert_left = ( __x != 0 || __p == _M_end ( )
|| _M_impl . _M_key_compare ( _S_key ( __z ) ,
_S_key ( __p ) ) ) ;

_Rb_tree_insert_and_rebalance ( __insert_left , __z , __p ,
this -> _M_impl . _M_header ) ;
++ _M_impl . _M_node_count ;
return iterator ( __z ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_insert_lower_node ( _Base_ptr __p , _Link_type __z )
{
bool __insert_left = ( __p == _M_end ( )
|| ! _M_impl . _M_key_compare ( _S_key ( __p ) ,
_S_key ( __z ) ) ) ;

_Rb_tree_insert_and_rebalance ( __insert_left , __z , __p ,
this -> _M_impl . _M_header ) ;
++ _M_impl . _M_node_count ;
return iterator ( __z ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_insert_equal_lower_node ( _Link_type __z )
{
_Link_type __x = _M_begin ( ) ;
_Link_type __y = _M_end ( ) ;
while ( __x != 0 )
{
__y = __x ;
__x = ! _M_impl . _M_key_compare ( _S_key ( __x ) , _S_key ( __z ) ) ?
_S_left ( __x ) : _S_right ( __x ) ;
}
return _M_insert_lower_node ( __y , __z ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
template < typename ... _Args >
pair < typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: iterator , bool >
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_emplace_unique ( _Args && ... __args )
{
_Link_type __z = _M_create_node ( std :: forward < _Args > ( __args ) ... ) ;

try
{
typedef pair < iterator , bool > _Res ;
auto __res = _M_get_insert_unique_pos ( _S_key ( __z ) ) ;
if ( __res . second )
return _Res ( _M_insert_node ( __res . first , __res . second , __z ) , true ) ;

_M_destroy_node ( __z ) ;
return _Res ( iterator ( static_cast < _Link_type > ( __res . first ) ) , false ) ;
}
catch ( ... )
{
_M_destroy_node ( __z ) ;
throw ;
}
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
template < typename ... _Args >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_emplace_equal ( _Args && ... __args )
{
_Link_type __z = _M_create_node ( std :: forward < _Args > ( __args ) ... ) ;

try
{
auto __res = _M_get_insert_equal_pos ( _S_key ( __z ) ) ;
return _M_insert_node ( __res . first , __res . second , __z ) ;
}
catch ( ... )
{
_M_destroy_node ( __z ) ;
throw ;
}
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
template < typename ... _Args >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_emplace_hint_unique ( const_iterator __pos , _Args && ... __args )
{
_Link_type __z = _M_create_node ( std :: forward < _Args > ( __args ) ... ) ;

try
{
auto __res = _M_get_insert_hint_unique_pos ( __pos , _S_key ( __z ) ) ;

if ( __res . second )
return _M_insert_node ( __res . first , __res . second , __z ) ;

_M_destroy_node ( __z ) ;
return iterator ( static_cast < _Link_type > ( __res . first ) ) ;
}
catch ( ... )
{
_M_destroy_node ( __z ) ;
throw ;
}
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
template < typename ... _Args >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_emplace_hint_equal ( const_iterator __pos , _Args && ... __args )
{
_Link_type __z = _M_create_node ( std :: forward < _Args > ( __args ) ... ) ;

try
{
auto __res = _M_get_insert_hint_equal_pos ( __pos , _S_key ( __z ) ) ;

if ( __res . second )
return _M_insert_node ( __res . first , __res . second , __z ) ;

return _M_insert_equal_lower_node ( __z ) ;
}
catch ( ... )
{
_M_destroy_node ( __z ) ;
throw ;
}
}


template < typename _Key , typename _Val , typename _KoV ,
typename _Cmp , typename _Alloc >
template < class _II >
void
_Rb_tree < _Key , _Val , _KoV , _Cmp , _Alloc > ::
_M_insert_unique ( _II __first , _II __last )
{
for ( ; __first != __last ; ++ __first )
_M_insert_unique_ ( end ( ) , * __first ) ;
}

template < typename _Key , typename _Val , typename _KoV ,
typename _Cmp , typename _Alloc >
template < class _II >
void
_Rb_tree < _Key , _Val , _KoV , _Cmp , _Alloc > ::
_M_insert_equal ( _II __first , _II __last )
{
for ( ; __first != __last ; ++ __first )
_M_insert_equal_ ( end ( ) , * __first ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
void
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_erase_aux ( const_iterator __position )
{
_Link_type __y =
static_cast < _Link_type > ( _Rb_tree_rebalance_for_erase
( const_cast < _Base_ptr > ( __position . _M_node ) ,
this -> _M_impl . _M_header ) ) ;
_M_destroy_node ( __y ) ;
-- _M_impl . _M_node_count ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
void
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
_M_erase_aux ( const_iterator __first , const_iterator __last )
{
if ( __first == begin ( ) && __last == end ( ) )
clear ( ) ;
else
while ( __first != __last )
erase ( __first ++ ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: size_type
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
erase ( const _Key & __x )
{
pair < iterator , iterator > __p = equal_range ( __x ) ;
const size_type __old_size = size ( ) ;
erase ( __p . first , __p . second ) ;
return __old_size - size ( ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
void
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
erase ( const _Key * __first , const _Key * __last )
{
while ( __first != __last )
erase ( * __first ++ ) ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
find ( const _Key & __k )
{
iterator __j = _M_lower_bound ( _M_begin ( ) , _M_end ( ) , __k ) ;
return ( __j == end ( )
|| _M_impl . _M_key_compare ( __k ,
_S_key ( __j . _M_node ) ) ) ? end ( ) : __j ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue ,
_Compare , _Alloc > :: const_iterator
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
find ( const _Key & __k ) const
{
const_iterator __j = _M_lower_bound ( _M_begin ( ) , _M_end ( ) , __k ) ;
return ( __j == end ( )
|| _M_impl . _M_key_compare ( __k ,
_S_key ( __j . _M_node ) ) ) ? end ( ) : __j ;
}

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
typename _Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: size_type
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > ::
count ( const _Key & __k ) const
{
pair < const_iterator , const_iterator > __p = equal_range ( __k ) ;
const size_type __n = std :: distance ( __p . first , __p . second ) ;
return __n ;
}

__attribute__ ( ( __pure__ ) ) unsigned int
_Rb_tree_black_count ( const _Rb_tree_node_base * __node ,
const _Rb_tree_node_base * __root ) throw ( ) ;

template < typename _Key , typename _Val , typename _KeyOfValue ,
typename _Compare , typename _Alloc >
bool
_Rb_tree < _Key , _Val , _KeyOfValue , _Compare , _Alloc > :: __rb_verify ( ) const
{
if ( _M_impl . _M_node_count == 0 || begin ( ) == end ( ) )
return _M_impl . _M_node_count == 0 && begin ( ) == end ( )
&& this -> _M_impl . _M_header . _M_left == _M_end ( )
&& this -> _M_impl . _M_header . _M_right == _M_end ( ) ;

unsigned int __len = _Rb_tree_black_count ( _M_leftmost ( ) , _M_root ( ) ) ;
for ( const_iterator __it = begin ( ) ; __it != end ( ) ; ++ __it )
{
_Const_Link_type __x = static_cast < _Const_Link_type > ( __it . _M_node ) ;
_Const_Link_type __L = _S_left ( __x ) ;
_Const_Link_type __R = _S_right ( __x ) ;

if ( __x -> _M_color == _S_red )
if ( ( __L && __L -> _M_color == _S_red )
|| ( __R && __R -> _M_color == _S_red ) )
return false ;

if ( __L && _M_impl . _M_key_compare ( _S_key ( __x ) , _S_key ( __L ) ) )
return false ;
if ( __R && _M_impl . _M_key_compare ( _S_key ( __R ) , _S_key ( __x ) ) )
return false ;

if ( ! __L && ! __R && _Rb_tree_black_count ( __x , _M_root ( ) ) != __len )
return false ;
}

if ( _M_leftmost ( ) != _Rb_tree_node_base :: _S_minimum ( _M_root ( ) ) )
return false ;
if ( _M_rightmost ( ) != _Rb_tree_node_base :: _S_maximum ( _M_root ( ) ) )
return false ;
return true ;
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_map.h"
#66
namespace std
{
#94
template < typename _Key , typename _Tp , typename _Compare = std :: less < _Key > ,
typename _Alloc = std :: allocator < std :: pair < const _Key , _Tp > > >
class map
{
public :
typedef _Key key_type ;
typedef _Tp mapped_type ;
typedef std :: pair < const _Key , _Tp > value_type ;
typedef _Compare key_compare ;
typedef _Alloc allocator_type ;

private :

typedef typename _Alloc :: value_type _Alloc_value_type ;





public :
class value_compare
: public std :: binary_function < value_type , value_type , bool >
{
friend class map < _Key , _Tp , _Compare , _Alloc > ;
protected :
_Compare comp ;

value_compare ( _Compare __c )
: comp ( __c ) { }

public :
bool operator ( ) ( const value_type & __x , const value_type & __y ) const
{ return comp ( __x . first , __y . first ) ; }
} ;

private :

typedef typename _Alloc :: template rebind < value_type > :: other
_Pair_alloc_type ;

typedef _Rb_tree < key_type , value_type , _Select1st < value_type > ,
key_compare , _Pair_alloc_type > _Rep_type ;


_Rep_type _M_t ;

public :


typedef typename _Pair_alloc_type :: pointer pointer ;
typedef typename _Pair_alloc_type :: const_pointer const_pointer ;
typedef typename _Pair_alloc_type :: reference reference ;
typedef typename _Pair_alloc_type :: const_reference const_reference ;
typedef typename _Rep_type :: iterator iterator ;
typedef typename _Rep_type :: const_iterator const_iterator ;
typedef typename _Rep_type :: size_type size_type ;
typedef typename _Rep_type :: difference_type difference_type ;
typedef typename _Rep_type :: reverse_iterator reverse_iterator ;
typedef typename _Rep_type :: const_reverse_iterator const_reverse_iterator ;
#160
map ( )
: _M_t ( ) { }
#168
explicit
map ( const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Pair_alloc_type ( __a ) ) { }
#180
map ( const map & __x )
: _M_t ( __x . _M_t ) { }
#191
map ( map && __x )
noexcept ( is_nothrow_copy_constructible < _Compare > :: value )
: _M_t ( std :: move ( __x . _M_t ) ) { }
#206
map ( initializer_list < value_type > __l ,
const _Compare & __comp = _Compare ( ) ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Pair_alloc_type ( __a ) )
{ _M_t . _M_insert_unique ( __l . begin ( ) , __l . end ( ) ) ; }
#223
template < typename _InputIterator >
map ( _InputIterator __first , _InputIterator __last )
: _M_t ( )
{ _M_t . _M_insert_unique ( __first , __last ) ; }
#240
template < typename _InputIterator >
map ( _InputIterator __first , _InputIterator __last ,
const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Pair_alloc_type ( __a ) )
{ _M_t . _M_insert_unique ( __first , __last ) ; }
#263
map &
operator = ( const map & __x )
{
_M_t = __x . _M_t ;
return * this ;
}
#278
map &
operator = ( map && __x )
{


this -> clear ( ) ;
this -> swap ( __x ) ;
return * this ;
}
#299
map &
operator = ( initializer_list < value_type > __l )
{
this -> clear ( ) ;
this -> insert ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}



allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_t . get_allocator ( ) ) ; }
#319
iterator
begin ( ) noexcept
{ return _M_t . begin ( ) ; }
#328
const_iterator
begin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#337
iterator
end ( ) noexcept
{ return _M_t . end ( ) ; }
#346
const_iterator
end ( ) const noexcept
{ return _M_t . end ( ) ; }
#355
reverse_iterator
rbegin ( ) noexcept
{ return _M_t . rbegin ( ) ; }
#364
const_reverse_iterator
rbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#373
reverse_iterator
rend ( ) noexcept
{ return _M_t . rend ( ) ; }
#382
const_reverse_iterator
rend ( ) const noexcept
{ return _M_t . rend ( ) ; }
#392
const_iterator
cbegin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#401
const_iterator
cend ( ) const noexcept
{ return _M_t . end ( ) ; }
#410
const_reverse_iterator
crbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#419
const_reverse_iterator
crend ( ) const noexcept
{ return _M_t . rend ( ) ; }
#428
bool
empty ( ) const noexcept
{ return _M_t . empty ( ) ; }


size_type
size ( ) const noexcept
{ return _M_t . size ( ) ; }


size_type
max_size ( ) const noexcept
{ return _M_t . max_size ( ) ; }
#455
mapped_type &
operator [ ] ( const key_type & __k )
{



iterator __i = lower_bound ( __k ) ;

if ( __i == end ( ) || key_comp ( ) ( __k , ( * __i ) . first ) )

__i = _M_t . _M_emplace_hint_unique ( __i , std :: piecewise_construct ,
std :: tuple < const key_type & > ( __k ) ,
std :: tuple < > ( ) ) ;



return ( * __i ) . second ;
}


mapped_type &
operator [ ] ( key_type && __k )
{



iterator __i = lower_bound ( __k ) ;

if ( __i == end ( ) || key_comp ( ) ( __k , ( * __i ) . first ) )
__i = _M_t . _M_emplace_hint_unique ( __i , std :: piecewise_construct ,
std :: forward_as_tuple ( std :: move ( __k ) ) ,
std :: tuple < > ( ) ) ;
return ( * __i ) . second ;
}
#500
mapped_type &
at ( const key_type & __k )
{
iterator __i = lower_bound ( __k ) ;
if ( __i == end ( ) || key_comp ( ) ( __k , ( * __i ) . first ) )
__throw_out_of_range ( ( "map::at" ) ) ;
return ( * __i ) . second ;
}

const mapped_type &
at ( const key_type & __k ) const
{
const_iterator __i = lower_bound ( __k ) ;
if ( __i == end ( ) || key_comp ( ) ( __k , ( * __i ) . first ) )
__throw_out_of_range ( ( "map::at" ) ) ;
return ( * __i ) . second ;
}
#538
template < typename ... _Args >
std :: pair < iterator , bool >
emplace ( _Args && ... __args )
{ return _M_t . _M_emplace_unique ( std :: forward < _Args > ( __args ) ... ) ; }
#568
template < typename ... _Args >
iterator
emplace_hint ( const_iterator __pos , _Args && ... __args )
{
return _M_t . _M_emplace_hint_unique ( __pos ,
std :: forward < _Args > ( __args ) ... ) ;
}
#593
std :: pair < iterator , bool >
insert ( const value_type & __x )
{ return _M_t . _M_insert_unique ( __x ) ; }


template < typename _Pair , typename = typename
std :: enable_if < std :: is_constructible < value_type ,
_Pair && > :: value > :: type >
std :: pair < iterator , bool >
insert ( _Pair && __x )
{ return _M_t . _M_insert_unique ( std :: forward < _Pair > ( __x ) ) ; }
#614
void
insert ( std :: initializer_list < value_type > __list )
{ insert ( __list . begin ( ) , __list . end ( ) ) ; }
#642
iterator

insert ( const_iterator __position , const value_type & __x )



{ return _M_t . _M_insert_unique_ ( __position , __x ) ; }


template < typename _Pair , typename = typename
std :: enable_if < std :: is_constructible < value_type ,
_Pair && > :: value > :: type >
iterator
insert ( const_iterator __position , _Pair && __x )
{ return _M_t . _M_insert_unique_ ( __position ,
std :: forward < _Pair > ( __x ) ) ; }
#668
template < typename _InputIterator >
void
insert ( _InputIterator __first , _InputIterator __last )
{ _M_t . _M_insert_unique ( __first , __last ) ; }
#689
iterator
erase ( const_iterator __position )
{ return _M_t . erase ( __position ) ; }


__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( iterator __position )
{ return _M_t . erase ( __position ) ; }
#725
size_type
erase ( const key_type & __x )
{ return _M_t . erase ( __x ) ; }
#745
iterator
erase ( const_iterator __first , const_iterator __last )
{ return _M_t . erase ( __first , __last ) ; }
#777
void
swap ( map & __x )
{ _M_t . swap ( __x . _M_t ) ; }
#787
void
clear ( ) noexcept
{ _M_t . clear ( ) ; }
#796
key_compare
key_comp ( ) const
{ return _M_t . key_comp ( ) ; }





value_compare
value_comp ( ) const
{ return value_compare ( _M_t . key_comp ( ) ) ; }
#820
iterator
find ( const key_type & __x )
{ return _M_t . find ( __x ) ; }
#835
const_iterator
find ( const key_type & __x ) const
{ return _M_t . find ( __x ) ; }
#847
size_type
count ( const key_type & __x ) const
{ return _M_t . find ( __x ) == _M_t . end ( ) ? 0 : 1 ; }
#862
iterator
lower_bound ( const key_type & __x )
{ return _M_t . lower_bound ( __x ) ; }
#877
const_iterator
lower_bound ( const key_type & __x ) const
{ return _M_t . lower_bound ( __x ) ; }
#887
iterator
upper_bound ( const key_type & __x )
{ return _M_t . upper_bound ( __x ) ; }
#897
const_iterator
upper_bound ( const key_type & __x ) const
{ return _M_t . upper_bound ( __x ) ; }
#916
std :: pair < iterator , iterator >
equal_range ( const key_type & __x )
{ return _M_t . equal_range ( __x ) ; }
#935
std :: pair < const_iterator , const_iterator >
equal_range ( const key_type & __x ) const
{ return _M_t . equal_range ( __x ) ; }

template < typename _K1 , typename _T1 , typename _C1 , typename _A1 >
friend bool
operator == ( const map < _K1 , _T1 , _C1 , _A1 > & ,
const map < _K1 , _T1 , _C1 , _A1 > & ) ;

template < typename _K1 , typename _T1 , typename _C1 , typename _A1 >
friend bool
operator < ( const map < _K1 , _T1 , _C1 , _A1 > & ,
const map < _K1 , _T1 , _C1 , _A1 > & ) ;
} ;
#960
template < typename _Key , typename _Tp , typename _Compare , typename _Alloc >
inline bool
operator == ( const map < _Key , _Tp , _Compare , _Alloc > & __x ,
const map < _Key , _Tp , _Compare , _Alloc > & __y )
{ return __x . _M_t == __y . _M_t ; }
#977
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 ) ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_multimap.h"
#64
namespace std
{
#92
template < typename _Key , typename _Tp ,
typename _Compare = std :: less < _Key > ,
typename _Alloc = std :: allocator < std :: pair < const _Key , _Tp > > >
class multimap
{
public :
typedef _Key key_type ;
typedef _Tp mapped_type ;
typedef std :: pair < const _Key , _Tp > value_type ;
typedef _Compare key_compare ;
typedef _Alloc allocator_type ;

private :

typedef typename _Alloc :: value_type _Alloc_value_type ;





public :
class value_compare
: public std :: binary_function < value_type , value_type , bool >
{
friend class multimap < _Key , _Tp , _Compare , _Alloc > ;
protected :
_Compare comp ;

value_compare ( _Compare __c )
: comp ( __c ) { }

public :
bool operator ( ) ( const value_type & __x , const value_type & __y ) const
{ return comp ( __x . first , __y . first ) ; }
} ;

private :

typedef typename _Alloc :: template rebind < value_type > :: other
_Pair_alloc_type ;

typedef _Rb_tree < key_type , value_type , _Select1st < value_type > ,
key_compare , _Pair_alloc_type > _Rep_type ;

_Rep_type _M_t ;

public :


typedef typename _Pair_alloc_type :: pointer pointer ;
typedef typename _Pair_alloc_type :: const_pointer const_pointer ;
typedef typename _Pair_alloc_type :: reference reference ;
typedef typename _Pair_alloc_type :: const_reference const_reference ;
typedef typename _Rep_type :: iterator iterator ;
typedef typename _Rep_type :: const_iterator const_iterator ;
typedef typename _Rep_type :: size_type size_type ;
typedef typename _Rep_type :: difference_type difference_type ;
typedef typename _Rep_type :: reverse_iterator reverse_iterator ;
typedef typename _Rep_type :: const_reverse_iterator const_reverse_iterator ;
#157
multimap ( )
: _M_t ( ) { }
#165
explicit
multimap ( const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Pair_alloc_type ( __a ) ) { }
#177
multimap ( const multimap & __x )
: _M_t ( __x . _M_t ) { }
#188
multimap ( multimap && __x )
noexcept ( is_nothrow_copy_constructible < _Compare > :: value )
: _M_t ( std :: move ( __x . _M_t ) ) { }
#202
multimap ( initializer_list < value_type > __l ,
const _Compare & __comp = _Compare ( ) ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Pair_alloc_type ( __a ) )
{ _M_t . _M_insert_equal ( __l . begin ( ) , __l . end ( ) ) ; }
#218
template < typename _InputIterator >
multimap ( _InputIterator __first , _InputIterator __last )
: _M_t ( )
{ _M_t . _M_insert_equal ( __first , __last ) ; }
#234
template < typename _InputIterator >
multimap ( _InputIterator __first , _InputIterator __last ,
const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Pair_alloc_type ( __a ) )
{ _M_t . _M_insert_equal ( __first , __last ) ; }
#257
multimap &
operator = ( const multimap & __x )
{
_M_t = __x . _M_t ;
return * this ;
}
#272
multimap &
operator = ( multimap && __x )
{


this -> clear ( ) ;
this -> swap ( __x ) ;
return * this ;
}
#293
multimap &
operator = ( initializer_list < value_type > __l )
{
this -> clear ( ) ;
this -> insert ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}



allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_t . get_allocator ( ) ) ; }
#313
iterator
begin ( ) noexcept
{ return _M_t . begin ( ) ; }
#322
const_iterator
begin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#331
iterator
end ( ) noexcept
{ return _M_t . end ( ) ; }
#340
const_iterator
end ( ) const noexcept
{ return _M_t . end ( ) ; }
#349
reverse_iterator
rbegin ( ) noexcept
{ return _M_t . rbegin ( ) ; }
#358
const_reverse_iterator
rbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#367
reverse_iterator
rend ( ) noexcept
{ return _M_t . rend ( ) ; }
#376
const_reverse_iterator
rend ( ) const noexcept
{ return _M_t . rend ( ) ; }
#386
const_iterator
cbegin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#395
const_iterator
cend ( ) const noexcept
{ return _M_t . end ( ) ; }
#404
const_reverse_iterator
crbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#413
const_reverse_iterator
crend ( ) const noexcept
{ return _M_t . rend ( ) ; }




bool
empty ( ) const noexcept
{ return _M_t . empty ( ) ; }


size_type
size ( ) const noexcept
{ return _M_t . size ( ) ; }


size_type
max_size ( ) const noexcept
{ return _M_t . max_size ( ) ; }
#452
template < typename ... _Args >
iterator
emplace ( _Args && ... __args )
{ return _M_t . _M_emplace_equal ( std :: forward < _Args > ( __args ) ... ) ; }
#479
template < typename ... _Args >
iterator
emplace_hint ( const_iterator __pos , _Args && ... __args )
{
return _M_t . _M_emplace_hint_equal ( __pos ,
std :: forward < _Args > ( __args ) ... ) ;
}
#500
iterator
insert ( const value_type & __x )
{ return _M_t . _M_insert_equal ( __x ) ; }


template < typename _Pair , typename = typename
std :: enable_if < std :: is_constructible < value_type ,
_Pair && > :: value > :: type >
iterator
insert ( _Pair && __x )
{ return _M_t . _M_insert_equal ( std :: forward < _Pair > ( __x ) ) ; }
#533
iterator

insert ( const_iterator __position , const value_type & __x )



{ return _M_t . _M_insert_equal_ ( __position , __x ) ; }


template < typename _Pair , typename = typename
std :: enable_if < std :: is_constructible < value_type ,
_Pair && > :: value > :: type >
iterator
insert ( const_iterator __position , _Pair && __x )
{ return _M_t . _M_insert_equal_ ( __position ,
std :: forward < _Pair > ( __x ) ) ; }
#560
template < typename _InputIterator >
void
insert ( _InputIterator __first , _InputIterator __last )
{ _M_t . _M_insert_equal ( __first , __last ) ; }
#573
void
insert ( initializer_list < value_type > __l )
{ this -> insert ( __l . begin ( ) , __l . end ( ) ) ; }
#594
iterator
erase ( const_iterator __position )
{ return _M_t . erase ( __position ) ; }


__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( iterator __position )
{ return _M_t . erase ( __position ) ; }
#630
size_type
erase ( const key_type & __x )
{ return _M_t . erase ( __x ) ; }
#651
iterator
erase ( const_iterator __first , const_iterator __last )
{ return _M_t . erase ( __first , __last ) ; }
#686
void
swap ( multimap & __x )
{ _M_t . swap ( __x . _M_t ) ; }
#696
void
clear ( ) noexcept
{ _M_t . clear ( ) ; }
#705
key_compare
key_comp ( ) const
{ return _M_t . key_comp ( ) ; }





value_compare
value_comp ( ) const
{ return value_compare ( _M_t . key_comp ( ) ) ; }
#729
iterator
find ( const key_type & __x )
{ return _M_t . find ( __x ) ; }
#744
const_iterator
find ( const key_type & __x ) const
{ return _M_t . find ( __x ) ; }
#753
size_type
count ( const key_type & __x ) const
{ return _M_t . count ( __x ) ; }
#768
iterator
lower_bound ( const key_type & __x )
{ return _M_t . lower_bound ( __x ) ; }
#783
const_iterator
lower_bound ( const key_type & __x ) const
{ return _M_t . lower_bound ( __x ) ; }
#793
iterator
upper_bound ( const key_type & __x )
{ return _M_t . upper_bound ( __x ) ; }
#803
const_iterator
upper_bound ( const key_type & __x ) const
{ return _M_t . upper_bound ( __x ) ; }
#820
std :: pair < iterator , iterator >
equal_range ( const key_type & __x )
{ return _M_t . equal_range ( __x ) ; }
#837
std :: pair < const_iterator , const_iterator >
equal_range ( const key_type & __x ) const
{ return _M_t . equal_range ( __x ) ; }

template < typename _K1 , typename _T1 , typename _C1 , typename _A1 >
friend bool
operator == ( const multimap < _K1 , _T1 , _C1 , _A1 > & ,
const multimap < _K1 , _T1 , _C1 , _A1 > & ) ;

template < typename _K1 , typename _T1 , typename _C1 , typename _A1 >
friend bool
operator < ( const multimap < _K1 , _T1 , _C1 , _A1 > & ,
const multimap < _K1 , _T1 , _C1 , _A1 > & ) ;
} ;
#862
template < typename _Key , typename _Tp , typename _Compare , typename _Alloc >
inline bool
operator == ( const multimap < _Key , _Tp , _Compare , _Alloc > & __x ,
const multimap < _Key , _Tp , _Compare , _Alloc > & __y )
{ return __x . _M_t == __y . _M_t ; }
#879
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 ) ; }


}
#1 "./boost/limits.hpp"
#1 "./boost/assert.hpp"
#1 "/usr/include/assert.h"
#1 "./boost/cstdint.hpp"
#194
namespace boost
{
#208
typedef signed char int8_t ;
typedef signed char int_least8_t ;
typedef signed char int_fast8_t ;
typedef unsigned char uint8_t ;
typedef unsigned char uint_least8_t ;
typedef unsigned char uint_fast8_t ;
#231
typedef short int16_t ;
typedef short int_least16_t ;
typedef short int_fast16_t ;
typedef unsigned short uint16_t ;
typedef unsigned short uint_least16_t ;
typedef unsigned short uint_fast16_t ;
#260
typedef int int32_t ;
typedef int int_least32_t ;
typedef int int_fast32_t ;
typedef unsigned int uint32_t ;
typedef unsigned int uint_least32_t ;
typedef unsigned int uint_fast32_t ;
#306
typedef :: boost :: long_long_type intmax_t ;
typedef :: boost :: ulong_long_type uintmax_t ;
typedef :: boost :: long_long_type int64_t ;
typedef :: boost :: long_long_type int_least64_t ;
typedef :: boost :: long_long_type int_fast64_t ;
typedef :: boost :: ulong_long_type uint64_t ;
typedef :: boost :: ulong_long_type uint_least64_t ;
typedef :: boost :: ulong_long_type uint_fast64_t ;
#356
}
#1 "./boost/throw_exception.hpp"
#1 "./boost/exception/detail/attribute_noreturn.hpp"
#1 "./boost/detail/workaround.hpp"
#1 "./boost/exception/exception.hpp"
#15
namespace
boost
{
namespace
exception_detail
{
template < class T >
class
refcount_ptr
{
public :

refcount_ptr ( ) :
px_ ( 0 )
{
}

~ refcount_ptr ( )
{
release ( ) ;
}

refcount_ptr ( refcount_ptr const & x ) :
px_ ( x . px_ )
{
add_ref ( ) ;
}

refcount_ptr &
operator = ( refcount_ptr const & x )
{
adopt ( x . px_ ) ;
return * this ;
}

void
adopt ( T * px )
{
release ( ) ;
px_ = px ;
add_ref ( ) ;
}

T *
get ( ) const
{
return px_ ;
}

private :

T * px_ ;

void
add_ref ( )
{
if ( px_ )
px_ -> add_ref ( ) ;
}

void
release ( )
{
if ( px_ && px_ -> release ( ) )
px_ = 0 ;
}
} ;
}



template < class Tag , class T >
class error_info ;

typedef error_info < struct throw_function_ , char const * > throw_function ;
typedef error_info < struct throw_file_ , char const * > throw_file ;
typedef error_info < struct throw_line_ , int > throw_line ;

template < >
class
error_info < throw_function_ , char const * >
{
public :
typedef char const * value_type ;
value_type v_ ;
explicit
error_info ( value_type v ) :
v_ ( v )
{
}
} ;

template < >
class
error_info < throw_file_ , char const * >
{
public :
typedef char const * value_type ;
value_type v_ ;
explicit
error_info ( value_type v ) :
v_ ( v )
{
}
} ;

template < >
class
error_info < throw_line_ , int >
{
public :
typedef int value_type ;
value_type v_ ;
explicit
error_info ( value_type v ) :
v_ ( v )
{
}
} ;
#140
class exception ;
#147
template < class T >
class shared_ptr ;

namespace
exception_detail
{
class error_info_base ;
struct type_info_ ;

struct
error_info_container
{
virtual char const * diagnostic_information ( char const * ) const = 0 ;
virtual shared_ptr < error_info_base > get ( type_info_ const & ) const = 0 ;
virtual void set ( shared_ptr < error_info_base > const & , type_info_ const & ) = 0 ;
virtual void add_ref ( ) const = 0 ;
virtual bool release ( ) const = 0 ;
virtual refcount_ptr < exception_detail :: error_info_container > clone ( ) const = 0 ;

protected :

~ error_info_container ( ) throw ( )
{
}
} ;

template < class >
struct get_info ;

template < >
struct get_info < throw_function > ;

template < >
struct get_info < throw_file > ;

template < >
struct get_info < throw_line > ;

char const * get_diagnostic_information ( exception const & , char const * ) ;

void copy_boost_exception ( exception * , exception const * ) ;

template < class E , class Tag , class T >
E const & set_info ( E const & , error_info < Tag , T > const & ) ;

template < class E >
E const & set_info ( E const & , throw_function const & ) ;

template < class E >
E const & set_info ( E const & , throw_file const & ) ;

template < class E >
E const & set_info ( E const & , throw_line const & ) ;
}
#207
class
exception
{
protected :

exception ( ) :
throw_function_ ( 0 ) ,
throw_file_ ( 0 ) ,
throw_line_ ( - 1 )
{
}
#231
virtual ~ exception ( ) throw ( )

= 0

;




private :

template < class E >
friend E const & exception_detail :: set_info ( E const & , throw_function const & ) ;

template < class E >
friend E const & exception_detail :: set_info ( E const & , throw_file const & ) ;

template < class E >
friend E const & exception_detail :: set_info ( E const & , throw_line const & ) ;

template < class E , class Tag , class T >
friend E const & exception_detail :: set_info ( E const & , error_info < Tag , T > const & ) ;

friend char const * exception_detail :: get_diagnostic_information ( exception const & , char const * ) ;

template < class >
friend struct exception_detail :: get_info ;
friend struct exception_detail :: get_info < throw_function > ;
friend struct exception_detail :: get_info < throw_file > ;
friend struct exception_detail :: get_info < throw_line > ;
friend void exception_detail :: copy_boost_exception ( exception * , exception const * ) ;

mutable exception_detail :: refcount_ptr < exception_detail :: error_info_container > data_ ;
mutable char const * throw_function_ ;
mutable char const * throw_file_ ;
mutable int throw_line_ ;
} ;
#274
inline
exception ::
~ exception ( ) throw ( )
{
}

namespace
exception_detail
{
template < class E >
E const &
set_info ( E const & x , throw_function const & y )
{
x . throw_function_ = y . v_ ;
return x ;
}

template < class E >
E const &
set_info ( E const & x , throw_file const & y )
{
x . throw_file_ = y . v_ ;
return x ;
}

template < class E >
E const &
set_info ( E const & x , throw_line const & y )
{
x . throw_line_ = y . v_ ;
return x ;
}
}



namespace
exception_detail
{





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

~ error_info_injector ( ) throw ( )
{
}
} ;
#340
struct large_size { char c [ 256 ] ; } ;
large_size dispatch_boost_exception ( exception const * ) ;

struct small_size { } ;
small_size dispatch_boost_exception ( void const * ) ;

template < class , int >
struct enable_error_info_helper ;

template < class T >
struct
enable_error_info_helper < T , sizeof ( large_size ) >
{
typedef T type ;
} ;

template < class T >
struct
enable_error_info_helper < T , sizeof ( small_size ) >
{
typedef error_info_injector < T > type ;
} ;

template < class T >
struct
enable_error_info_return_type
{
typedef typename enable_error_info_helper < T , sizeof ( exception_detail :: dispatch_boost_exception ( static_cast < T *
#367
> ( 0 ) ) ) > :: type type ;
} ;
}

template < class T >
inline
typename
exception_detail :: enable_error_info_return_type < T > :: type
enable_error_info ( T const & x )
{
typedef typename exception_detail :: enable_error_info_return_type < T > :: type rt ;
return rt ( x ) ;
}



namespace
exception_detail
{





class
clone_base
{
public :

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

virtual
~ clone_base ( ) throw ( )
{
}
} ;
#410
inline
void
copy_boost_exception ( exception * a , exception const * b )
{
refcount_ptr < error_info_container > data ;
if ( error_info_container * d = b -> data_ . get ( ) )
data = d -> clone ( ) ;
a -> throw_file_ = b -> throw_file_ ;
a -> throw_line_ = b -> throw_line_ ;
a -> throw_function_ = b -> throw_function_ ;
a -> data_ = data ;
}

inline
void
copy_boost_exception ( void * , void const * )
{
}

template < class T >
class
clone_impl :
public T ,
public virtual clone_base
{
struct clone_tag { } ;
clone_impl ( clone_impl const & x , clone_tag ) :
T ( x )
{
copy_boost_exception ( this , & x ) ;
}

public :

explicit
clone_impl ( T const & x ) :
T ( x )
{
copy_boost_exception ( this , & x ) ;
}

~ clone_impl ( ) throw ( )
{
}

private :

clone_base const *
clone ( ) const
{
return new clone_impl ( * this , clone_tag ( ) ) ;
}

void
rethrow ( ) const
{
throw * this ;
}
} ;
}

template < class T >
inline
exception_detail :: clone_impl < T >
enable_current_exception ( T const & x )
{
return exception_detail :: clone_impl < T > ( x ) ;
}
}
#1 "./boost/current_function.hpp"
#22
namespace boost
{

namespace detail
{

inline void current_function_helper ( )
{
#61
}

}

}
#50 "./boost/throw_exception.hpp"
namespace boost
{
#58
inline void throw_exception_assert_compatibility ( std :: exception const & ) { }

template < class E > inline void throw_exception ( E const & e )
{


throw_exception_assert_compatibility ( e ) ;


throw enable_current_exception ( enable_error_info ( e ) ) ;



}




namespace
exception_detail
{
template < class E >

void
throw_exception_ ( E const & x , char const * current_function , char const * file , int line )
{
boost :: throw_exception (
set_info (
set_info (
set_info (
enable_error_info ( x ) ,
throw_function ( current_function ) ) ,
throw_file ( file ) ) ,
throw_line ( line ) ) ) ;
}
}

}
#1 "./boost/scoped_ptr.hpp"
#1 "./boost/smart_ptr/scoped_ptr.hpp"
#1 "./boost/assert.hpp"
#1 "/usr/include/assert.h"
#1 "./boost/checked_delete.hpp"
#24
namespace boost
{



template < class T > inline void checked_delete ( T * x )
{

typedef char type_must_be_complete [ sizeof ( T ) ? 1 : - 1 ] ;
( void ) sizeof ( type_must_be_complete ) ;
delete x ;
}

template < class T > inline void checked_array_delete ( T * x )
{
typedef char type_must_be_complete [ sizeof ( T ) ? 1 : - 1 ] ;
( void ) sizeof ( type_must_be_complete ) ;
delete [ ] x ;
}

template < class T > struct checked_deleter
{
typedef void result_type ;
typedef T * argument_type ;

void operator ( ) ( T * x ) const
{

boost :: checked_delete ( x ) ;
}
} ;

template < class T > struct checked_array_deleter
{
typedef void result_type ;
typedef T * argument_type ;

void operator ( ) ( T * x ) const
{
boost :: checked_array_delete ( x ) ;
}
} ;

}
#1 "./boost/smart_ptr/detail/sp_nullptr_t.hpp"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/memory"
#46
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_raw_storage_iter.h"
#59
namespace std
{
#67
template < class _OutputIterator , class _Tp >
class raw_storage_iterator
: public iterator < output_iterator_tag , void , void , void , void >
{
protected :
_OutputIterator _M_iter ;

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

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

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

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

raw_storage_iterator < _OutputIterator , _Tp >
operator ++ ( int )
{
raw_storage_iterator < _OutputIterator , _Tp > __tmp = * this ;
++ _M_iter ;
return __tmp ;
}
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ext/concurrence.h"
#32
#pragma GCC system_header
#40
namespace __gnu_cxx
{
#49
enum _Lock_policy { _S_single , _S_mutex , _S_atomic } ;



static const _Lock_policy __default_lock_policy =





_S_mutex ;
#67
class __concurrence_lock_error : public std :: exception
{
public :
virtual char const *
what ( ) const throw ( )
{ return "__gnu_cxx::__concurrence_lock_error" ; }
} ;

class __concurrence_unlock_error : public std :: exception
{
public :
virtual char const *
what ( ) const throw ( )
{ return "__gnu_cxx::__concurrence_unlock_error" ; }
} ;

class __concurrence_broadcast_error : public std :: exception
{
public :
virtual char const *
what ( ) const throw ( )
{ return "__gnu_cxx::__concurrence_broadcast_error" ; }
} ;

class __concurrence_wait_error : public std :: exception
{
public :
virtual char const *
what ( ) const throw ( )
{ return "__gnu_cxx::__concurrence_wait_error" ; }
} ;


inline void
__throw_concurrence_lock_error ( )
{ ( throw ( __concurrence_lock_error ( ) ) ) ; }

inline void
__throw_concurrence_unlock_error ( )
{ ( throw ( __concurrence_unlock_error ( ) ) ) ; }


inline void
__throw_concurrence_broadcast_error ( )
{ ( throw ( __concurrence_broadcast_error ( ) ) ) ; }

inline void
__throw_concurrence_wait_error ( )
{ ( throw ( __concurrence_wait_error ( ) ) ) ; }


class __mutex
{
private :



__gthread_mutex_t _M_mutex ;


__mutex ( const __mutex & ) ;
__mutex & operator = ( const __mutex & ) ;

public :
__mutex ( )
{

if ( __gthread_active_p ( ) )
__gthread_mutex_init_function ( & _M_mutex ) ;

}


~ __mutex ( )
{
if ( __gthread_active_p ( ) )
__gthread_mutex_destroy ( & _M_mutex ) ;
}


void lock ( )
{

if ( __gthread_active_p ( ) )
{
if ( __gthread_mutex_lock ( & _M_mutex ) != 0 )
__throw_concurrence_lock_error ( ) ;
}

}

void unlock ( )
{

if ( __gthread_active_p ( ) )
{
if ( __gthread_mutex_unlock ( & _M_mutex ) != 0 )
__throw_concurrence_unlock_error ( ) ;
}

}

__gthread_mutex_t * gthread_mutex ( void )
{ return & _M_mutex ; }
} ;

class __recursive_mutex
{
private :



__gthread_recursive_mutex_t _M_mutex ;


__recursive_mutex ( const __recursive_mutex & ) ;
__recursive_mutex & operator = ( const __recursive_mutex & ) ;

public :
__recursive_mutex ( )
{

if ( __gthread_active_p ( ) )
__gthread_recursive_mutex_init_function ( & _M_mutex ) ;

}


~ __recursive_mutex ( )
{
if ( __gthread_active_p ( ) )
__gthread_recursive_mutex_destroy ( & _M_mutex ) ;
}


void lock ( )
{

if ( __gthread_active_p ( ) )
{
if ( __gthread_recursive_mutex_lock ( & _M_mutex ) != 0 )
__throw_concurrence_lock_error ( ) ;
}

}

void unlock ( )
{

if ( __gthread_active_p ( ) )
{
if ( __gthread_recursive_mutex_unlock ( & _M_mutex ) != 0 )
__throw_concurrence_unlock_error ( ) ;
}

}

__gthread_recursive_mutex_t * gthread_recursive_mutex ( void )
{ return & _M_mutex ; }
} ;




class __scoped_lock
{
public :
typedef __mutex __mutex_type ;

private :
__mutex_type & _M_device ;

__scoped_lock ( const __scoped_lock & ) ;
__scoped_lock & operator = ( const __scoped_lock & ) ;

public :
explicit __scoped_lock ( __mutex_type & __name ) : _M_device ( __name )
{ _M_device . lock ( ) ; }

~ __scoped_lock ( ) throw ( )
{ _M_device . unlock ( ) ; }
} ;


class __cond
{
private :



__gthread_cond_t _M_cond ;


__cond ( const __cond & ) ;
__cond & operator = ( const __cond & ) ;

public :
__cond ( )
{

if ( __gthread_active_p ( ) )
__gthread_cond_init_function ( & _M_cond ) ;

}


~ __cond ( )
{
if ( __gthread_active_p ( ) )
__gthread_cond_destroy ( & _M_cond ) ;
}


void broadcast ( )
{

if ( __gthread_active_p ( ) )
{
if ( __gthread_cond_broadcast ( & _M_cond ) != 0 )
__throw_concurrence_broadcast_error ( ) ;
}

}

void wait ( __mutex * mutex )
{

{
if ( __gthread_cond_wait ( & _M_cond , mutex -> gthread_mutex ( ) ) != 0 )
__throw_concurrence_wait_error ( ) ;
}

}

void wait_recursive ( __recursive_mutex * mutex )
{

{
if ( __gthread_cond_wait_recursive ( & _M_cond ,
mutex -> gthread_recursive_mutex ( ) )
!= 0 )
__throw_concurrence_wait_error ( ) ;
}

}
} ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/unique_ptr.h"
#39
namespace std
{
#49
template < typename > class auto_ptr ;



template < typename _Tp >
struct default_delete
{
constexpr default_delete ( ) noexcept = default ;

template < typename _Up , typename = typename
enable_if < is_convertible < _Up * , _Tp * > :: value > :: type >
default_delete ( const default_delete < _Up > & ) noexcept { }

void
operator ( ) ( _Tp * __ptr ) const
{
static_assert ( sizeof ( _Tp ) > 0 ,
"can't delete pointer to incomplete type" ) ;
delete __ptr ;
}
} ;




template < typename _Tp >
struct default_delete < _Tp [ ] >
{
private :
template < typename _Up >
using __remove_cv = typename remove_cv < _Up > :: type ;


template < typename _Up >
using __is_derived_Tp
= __and_ < is_base_of < _Tp , _Up > ,
__not_ < is_same < __remove_cv < _Tp > , __remove_cv < _Up >> > > ;

public :
constexpr default_delete ( ) noexcept = default ;

template < typename _Up , typename = typename
enable_if < ! __is_derived_Tp < _Up > :: value > :: type >
default_delete ( const default_delete < _Up [ ] > & ) noexcept { }

void
operator ( ) ( _Tp * __ptr ) const
{
static_assert ( sizeof ( _Tp ) > 0 ,
"can't delete pointer to incomplete type" ) ;
delete [ ] __ptr ;
}

template < typename _Up >
typename enable_if < __is_derived_Tp < _Up > :: value > :: type
operator ( ) ( _Up * ) const = delete ;
} ;


template < typename _Tp , typename _Dp = default_delete < _Tp > >
class unique_ptr
{

class _Pointer
{
template < typename _Up >
static typename _Up :: pointer __test ( typename _Up :: pointer * ) ;

template < typename _Up >
static _Tp * __test ( ... ) ;

typedef typename remove_reference < _Dp > :: type _Del ;

public :
typedef decltype ( __test < _Del > ( 0 ) ) type ;
} ;

typedef std :: tuple < typename _Pointer :: type , _Dp > __tuple_type ;
__tuple_type _M_t ;

public :
typedef typename _Pointer :: type pointer ;
typedef _Tp element_type ;
typedef _Dp deleter_type ;


constexpr unique_ptr ( ) noexcept
: _M_t ( )
{ static_assert ( ! is_pointer < deleter_type > :: value ,
"constructed with null function pointer deleter" ) ; }

explicit
unique_ptr ( pointer __p ) noexcept
: _M_t ( __p , deleter_type ( ) )
{ static_assert ( ! is_pointer < deleter_type > :: value ,
"constructed with null function pointer deleter" ) ; }

unique_ptr ( pointer __p ,
typename conditional < is_reference < deleter_type > :: value ,
deleter_type , const deleter_type & > :: type __d ) noexcept
: _M_t ( __p , __d ) { }

unique_ptr ( pointer __p ,
typename remove_reference < deleter_type > :: type && __d ) noexcept
: _M_t ( std :: move ( __p ) , std :: move ( __d ) )
{ static_assert ( ! std :: is_reference < deleter_type > :: value ,
"rvalue deleter bound to reference" ) ; }

constexpr unique_ptr ( nullptr_t ) noexcept : unique_ptr ( ) { }


unique_ptr ( unique_ptr && __u ) noexcept
: _M_t ( __u . release ( ) , std :: forward < deleter_type > ( __u . get_deleter ( ) ) ) { }

template < typename _Up , typename _Ep , typename = _Require <
is_convertible < typename unique_ptr < _Up , _Ep > :: pointer , pointer > ,
__not_ < is_array < _Up >> ,
typename conditional < is_reference < _Dp > :: value ,
is_same < _Ep , _Dp > ,
is_convertible < _Ep , _Dp >> :: type >>
unique_ptr ( unique_ptr < _Up , _Ep > && __u ) noexcept
: _M_t ( __u . release ( ) , std :: forward < _Ep > ( __u . get_deleter ( ) ) )
{ }


template < typename _Up , typename = _Require <
is_convertible < _Up * , _Tp * > , is_same < _Dp , default_delete < _Tp >> >>
unique_ptr ( auto_ptr < _Up > && __u ) noexcept ;



~ unique_ptr ( ) noexcept
{
auto & __ptr = std :: get < 0 > ( _M_t ) ;
if ( __ptr != nullptr )
get_deleter ( ) ( __ptr ) ;
__ptr = pointer ( ) ;
}


unique_ptr &
operator = ( unique_ptr && __u ) noexcept
{
reset ( __u . release ( ) ) ;
get_deleter ( ) = std :: forward < deleter_type > ( __u . get_deleter ( ) ) ;
return * this ;
}

template < typename _Up , typename _Ep >
typename enable_if < __and_ <
is_convertible < typename unique_ptr < _Up , _Ep > :: pointer , pointer > ,
__not_ < is_array < _Up >>
> :: value ,
unique_ptr & > :: type
operator = ( unique_ptr < _Up , _Ep > && __u ) noexcept
{
reset ( __u . release ( ) ) ;
get_deleter ( ) = std :: forward < _Ep > ( __u . get_deleter ( ) ) ;
return * this ;
}

unique_ptr &
operator = ( nullptr_t ) noexcept
{
reset ( ) ;
return * this ;
}


typename add_lvalue_reference < element_type > :: type
operator * ( ) const
{
;
return * get ( ) ;
}

pointer
operator -> ( ) const noexcept
{
;
return get ( ) ;
}

pointer
get ( ) const noexcept
{ return std :: get < 0 > ( _M_t ) ; }

deleter_type &
get_deleter ( ) noexcept
{ return std :: get < 1 > ( _M_t ) ; }

const deleter_type &
get_deleter ( ) const noexcept
{ return std :: get < 1 > ( _M_t ) ; }

explicit operator bool ( ) const noexcept
{ return get ( ) == pointer ( ) ? false : true ; }


pointer
release ( ) noexcept
{
pointer __p = get ( ) ;
std :: get < 0 > ( _M_t ) = pointer ( ) ;
return __p ;
}

void
reset ( pointer __p = pointer ( ) ) noexcept
{
using std :: swap ;
swap ( std :: get < 0 > ( _M_t ) , __p ) ;
if ( __p != pointer ( ) )
get_deleter ( ) ( __p ) ;
}

void
swap ( unique_ptr & __u ) noexcept
{
using std :: swap ;
swap ( _M_t , __u . _M_t ) ;
}


unique_ptr ( const unique_ptr & ) = delete ;
unique_ptr & operator = ( const unique_ptr & ) = delete ;
} ;





template < typename _Tp , typename _Dp >
class unique_ptr < _Tp [ ] , _Dp >
{

class _Pointer
{
template < typename _Up >
static typename _Up :: pointer __test ( typename _Up :: pointer * ) ;

template < typename _Up >
static _Tp * __test ( ... ) ;

typedef typename remove_reference < _Dp > :: type _Del ;

public :
typedef decltype ( __test < _Del > ( 0 ) ) type ;
} ;

typedef std :: tuple < typename _Pointer :: type , _Dp > __tuple_type ;
__tuple_type _M_t ;

template < typename _Up >
using __remove_cv = typename remove_cv < _Up > :: type ;


template < typename _Up >
using __is_derived_Tp
= __and_ < is_base_of < _Tp , _Up > ,
__not_ < is_same < __remove_cv < _Tp > , __remove_cv < _Up >> > > ;

template < typename _Up , typename _Ep ,
typename _Tp_pointer = typename _Pointer :: type ,
typename _Up_pointer = typename unique_ptr < _Up , _Ep > :: pointer >
using __safe_conversion = __and_ <
is_convertible < _Up_pointer , _Tp_pointer > ,
is_array < _Up > ,
__or_ < __not_ < is_pointer < _Up_pointer >> ,
__not_ < is_pointer < _Tp_pointer >> ,
__not_ < __is_derived_Tp < typename remove_extent < _Up > :: type >>
>
> ;

public :
typedef typename _Pointer :: type pointer ;
typedef _Tp element_type ;
typedef _Dp deleter_type ;


constexpr unique_ptr ( ) noexcept
: _M_t ( )
{ static_assert ( ! std :: is_pointer < deleter_type > :: value ,
"constructed with null function pointer deleter" ) ; }

explicit
unique_ptr ( pointer __p ) noexcept
: _M_t ( __p , deleter_type ( ) )
{ static_assert ( ! is_pointer < deleter_type > :: value ,
"constructed with null function pointer deleter" ) ; }

template < typename _Up , typename = _Require < is_pointer < pointer > ,
is_convertible < _Up * , pointer > , __is_derived_Tp < _Up >> >
explicit
unique_ptr ( _Up * __p ) = delete ;

unique_ptr ( pointer __p ,
typename conditional < is_reference < deleter_type > :: value ,
deleter_type , const deleter_type & > :: type __d ) noexcept
: _M_t ( __p , __d ) { }

unique_ptr ( pointer __p , typename
remove_reference < deleter_type > :: type && __d ) noexcept
: _M_t ( std :: move ( __p ) , std :: move ( __d ) )
{ static_assert ( ! is_reference < deleter_type > :: value ,
"rvalue deleter bound to reference" ) ; }


unique_ptr ( unique_ptr && __u ) noexcept
: _M_t ( __u . release ( ) , std :: forward < deleter_type > ( __u . get_deleter ( ) ) ) { }

constexpr unique_ptr ( nullptr_t ) noexcept : unique_ptr ( ) { }

template < typename _Up , typename _Ep ,
typename = _Require < __safe_conversion < _Up , _Ep > ,
typename conditional < is_reference < _Dp > :: value ,
is_same < _Ep , _Dp > ,
is_convertible < _Ep , _Dp >> :: type
>>
unique_ptr ( unique_ptr < _Up , _Ep > && __u ) noexcept
: _M_t ( __u . release ( ) , std :: forward < _Ep > ( __u . get_deleter ( ) ) )
{ }


~ unique_ptr ( )
{
auto & __ptr = std :: get < 0 > ( _M_t ) ;
if ( __ptr != nullptr )
get_deleter ( ) ( __ptr ) ;
__ptr = pointer ( ) ;
}


unique_ptr &
operator = ( unique_ptr && __u ) noexcept
{
reset ( __u . release ( ) ) ;
get_deleter ( ) = std :: forward < deleter_type > ( __u . get_deleter ( ) ) ;
return * this ;
}

template < typename _Up , typename _Ep >
typename
enable_if < __safe_conversion < _Up , _Ep > :: value , unique_ptr & > :: type
operator = ( unique_ptr < _Up , _Ep > && __u ) noexcept
{
reset ( __u . release ( ) ) ;
get_deleter ( ) = std :: forward < _Ep > ( __u . get_deleter ( ) ) ;
return * this ;
}

unique_ptr &
operator = ( nullptr_t ) noexcept
{
reset ( ) ;
return * this ;
}


typename std :: add_lvalue_reference < element_type > :: type
operator [ ] ( size_t __i ) const
{
;
return get ( ) [ __i ] ;
}

pointer
get ( ) const noexcept
{ return std :: get < 0 > ( _M_t ) ; }

deleter_type &
get_deleter ( ) noexcept
{ return std :: get < 1 > ( _M_t ) ; }

const deleter_type &
get_deleter ( ) const noexcept
{ return std :: get < 1 > ( _M_t ) ; }

explicit operator bool ( ) const noexcept
{ return get ( ) == pointer ( ) ? false : true ; }


pointer
release ( ) noexcept
{
pointer __p = get ( ) ;
std :: get < 0 > ( _M_t ) = pointer ( ) ;
return __p ;
}

void
reset ( ) noexcept
{ reset ( pointer ( ) ) ; }

void
reset ( pointer __p ) noexcept
{
using std :: swap ;
swap ( std :: get < 0 > ( _M_t ) , __p ) ;
if ( __p != nullptr )
get_deleter ( ) ( __p ) ;
}

template < typename _Up , typename = _Require < is_pointer < pointer > ,
is_convertible < _Up * , pointer > , __is_derived_Tp < _Up >> >
void reset ( _Up * ) = delete ;

void
swap ( unique_ptr & __u ) noexcept
{
using std :: swap ;
swap ( _M_t , __u . _M_t ) ;
}


unique_ptr ( const unique_ptr & ) = delete ;
unique_ptr & operator = ( const unique_ptr & ) = delete ;


template < typename _Up , typename = _Require < is_pointer < pointer > ,
is_convertible < _Up * , pointer > , __is_derived_Tp < _Up >> >
unique_ptr ( _Up * , typename
conditional < is_reference < deleter_type > :: value ,
deleter_type , const deleter_type & > :: type ) = delete ;

template < typename _Up , typename = _Require < is_pointer < pointer > ,
is_convertible < _Up * , pointer > , __is_derived_Tp < _Up >> >
unique_ptr ( _Up * , typename
remove_reference < deleter_type > :: type && ) = delete ;
} ;

template < typename _Tp , typename _Dp >
inline void
swap ( unique_ptr < _Tp , _Dp > & __x ,
unique_ptr < _Tp , _Dp > & __y ) noexcept
{ __x . swap ( __y ) ; }

template < typename _Tp , typename _Dp ,
typename _Up , typename _Ep >
inline bool
operator == ( const unique_ptr < _Tp , _Dp > & __x ,
const unique_ptr < _Up , _Ep > & __y )
{ return __x . get ( ) == __y . get ( ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator == ( const unique_ptr < _Tp , _Dp > & __x , nullptr_t ) noexcept
{ return ! __x ; }

template < typename _Tp , typename _Dp >
inline bool
operator == ( nullptr_t , const unique_ptr < _Tp , _Dp > & __x ) noexcept
{ return ! __x ; }

template < typename _Tp , typename _Dp ,
typename _Up , typename _Ep >
inline bool
operator != ( const unique_ptr < _Tp , _Dp > & __x ,
const unique_ptr < _Up , _Ep > & __y )
{ return __x . get ( ) != __y . get ( ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator != ( const unique_ptr < _Tp , _Dp > & __x , nullptr_t ) noexcept
{ return ( bool ) __x ; }

template < typename _Tp , typename _Dp >
inline bool
operator != ( nullptr_t , const unique_ptr < _Tp , _Dp > & __x ) noexcept
{ return ( bool ) __x ; }

template < typename _Tp , typename _Dp ,
typename _Up , typename _Ep >
inline bool
operator < ( const unique_ptr < _Tp , _Dp > & __x ,
const unique_ptr < _Up , _Ep > & __y )
{
typedef typename
std :: common_type < typename unique_ptr < _Tp , _Dp > :: pointer ,
typename unique_ptr < _Up , _Ep > :: pointer > :: type _CT ;
return std :: less < _CT > ( ) ( __x . get ( ) , __y . get ( ) ) ;
}

template < typename _Tp , typename _Dp >
inline bool
operator < ( const unique_ptr < _Tp , _Dp > & __x , nullptr_t )
{ return std :: less < typename unique_ptr < _Tp , _Dp > :: pointer > ( ) ( __x . get ( ) ,
nullptr ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator < ( nullptr_t , const unique_ptr < _Tp , _Dp > & __x )
{ return std :: less < typename unique_ptr < _Tp , _Dp > :: pointer > ( ) ( nullptr ,
__x . get ( ) ) ; }

template < typename _Tp , typename _Dp ,
typename _Up , typename _Ep >
inline bool
operator <= ( const unique_ptr < _Tp , _Dp > & __x ,
const unique_ptr < _Up , _Ep > & __y )
{ return ! ( __y < __x ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator <= ( const unique_ptr < _Tp , _Dp > & __x , nullptr_t )
{ return ! ( nullptr < __x ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator <= ( nullptr_t , const unique_ptr < _Tp , _Dp > & __x )
{ return ! ( __x < nullptr ) ; }

template < typename _Tp , typename _Dp ,
typename _Up , typename _Ep >
inline bool
operator > ( const unique_ptr < _Tp , _Dp > & __x ,
const unique_ptr < _Up , _Ep > & __y )
{ return ( __y < __x ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator > ( const unique_ptr < _Tp , _Dp > & __x , nullptr_t )
{ return std :: less < typename unique_ptr < _Tp , _Dp > :: pointer > ( ) ( nullptr ,
__x . get ( ) ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator > ( nullptr_t , const unique_ptr < _Tp , _Dp > & __x )
{ return std :: less < typename unique_ptr < _Tp , _Dp > :: pointer > ( ) ( __x . get ( ) ,
nullptr ) ; }

template < typename _Tp , typename _Dp ,
typename _Up , typename _Ep >
inline bool
operator >= ( const unique_ptr < _Tp , _Dp > & __x ,
const unique_ptr < _Up , _Ep > & __y )
{ return ! ( __x < __y ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator >= ( const unique_ptr < _Tp , _Dp > & __x , nullptr_t )
{ return ! ( __x < nullptr ) ; }

template < typename _Tp , typename _Dp >
inline bool
operator >= ( nullptr_t , const unique_ptr < _Tp , _Dp > & __x )
{ return ! ( nullptr < __x ) ; }


template < typename _Tp , typename _Dp >
struct hash < unique_ptr < _Tp , _Dp >>
: public __hash_base < size_t , unique_ptr < _Tp , _Dp >>
{
size_t
operator ( ) ( const unique_ptr < _Tp , _Dp > & __u ) const noexcept
{
typedef unique_ptr < _Tp , _Dp > _UP ;
return std :: hash < typename _UP :: pointer > ( ) ( __u . get ( ) ) ;
}
} ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/shared_ptr.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/shared_ptr_base.h"
#52
namespace std
{



template < typename > class auto_ptr ;
#64
class bad_weak_ptr : public std :: exception
{
public :
virtual char const *
what ( ) const noexcept ;

virtual ~ bad_weak_ptr ( ) noexcept ;
} ;


inline void
__throw_bad_weak_ptr ( )
{ ( throw ( bad_weak_ptr ( ) ) ) ; }

using __gnu_cxx :: _Lock_policy ;
using __gnu_cxx :: __default_lock_policy ;
using __gnu_cxx :: _S_single ;
using __gnu_cxx :: _S_mutex ;
using __gnu_cxx :: _S_atomic ;


template < _Lock_policy _Lp >
class _Mutex_base
{
protected :

enum { _S_need_barriers = 0 } ;
} ;

template < >
class _Mutex_base < _S_mutex >
: public __gnu_cxx :: __mutex
{
protected :



enum { _S_need_barriers = 1 } ;
} ;

template < _Lock_policy _Lp = __default_lock_policy >
class _Sp_counted_base
: public _Mutex_base < _Lp >
{
public :
_Sp_counted_base ( ) noexcept
: _M_use_count ( 1 ) , _M_weak_count ( 1 ) { }

virtual
~ _Sp_counted_base ( ) noexcept
{ }



virtual void
_M_dispose ( ) noexcept = 0 ;


virtual void
_M_destroy ( ) noexcept
{ delete this ; }

virtual void *
_M_get_deleter ( const std :: type_info & ) = 0 ;

void
_M_add_ref_copy ( )
{ __gnu_cxx :: __atomic_add_dispatch ( & _M_use_count , 1 ) ; }

void
_M_add_ref_lock ( ) ;

void
_M_release ( ) noexcept
{

;
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & _M_use_count , - 1 ) == 1 )
{
;
_M_dispose ( ) ;




if ( _Mutex_base < _Lp > :: _S_need_barriers )
{
asm volatile ( "" :: : "memory" ) ;
asm volatile ( "" :: : "memory" ) ;
}


;
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & _M_weak_count ,
- 1 ) == 1 )
{
;
_M_destroy ( ) ;
}
}
}

void
_M_weak_add_ref ( ) noexcept
{ __gnu_cxx :: __atomic_add_dispatch ( & _M_weak_count , 1 ) ; }

void
_M_weak_release ( ) noexcept
{

;
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & _M_weak_count , - 1 ) == 1 )
{
;
if ( _Mutex_base < _Lp > :: _S_need_barriers )
{


asm volatile ( "" :: : "memory" ) ;
asm volatile ( "" :: : "memory" ) ;
}
_M_destroy ( ) ;
}
}

long
_M_get_use_count ( ) const noexcept
{


return __atomic_load_n ( & _M_use_count , 0 ) ;
}

private :
_Sp_counted_base ( _Sp_counted_base const & ) = delete ;
_Sp_counted_base & operator = ( _Sp_counted_base const & ) = delete ;

_Atomic_word _M_use_count ;
_Atomic_word _M_weak_count ;
} ;

template < >
inline void
_Sp_counted_base < _S_single > ::
_M_add_ref_lock ( )
{
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & _M_use_count , 1 ) == 0 )
{
_M_use_count = 0 ;
__throw_bad_weak_ptr ( ) ;
}
}

template < >
inline void
_Sp_counted_base < _S_mutex > ::
_M_add_ref_lock ( )
{
__gnu_cxx :: __scoped_lock sentry ( * this ) ;
if ( __gnu_cxx :: __exchange_and_add_dispatch ( & _M_use_count , 1 ) == 0 )
{
_M_use_count = 0 ;
__throw_bad_weak_ptr ( ) ;
}
}

template < >
inline void
_Sp_counted_base < _S_atomic > ::
_M_add_ref_lock ( )
{

_Atomic_word __count = _M_use_count ;
do
{
if ( __count == 0 )
__throw_bad_weak_ptr ( ) ;


}
while ( !

__builtin_atomic_compare_exchange_n ( ( void * ) ( & _M_use_count ) , ( void * ) ( & __count ) , ( __count + 1 ) , ( true
#246
) , ( 4 ) , ( 0 ) ) ) ;
}



template < typename _Tp , _Lock_policy _Lp = __default_lock_policy >
class __shared_ptr ;

template < typename _Tp , _Lock_policy _Lp = __default_lock_policy >
class __weak_ptr ;

template < typename _Tp , _Lock_policy _Lp = __default_lock_policy >
class __enable_shared_from_this ;

template < typename _Tp >
class shared_ptr ;

template < typename _Tp >
class weak_ptr ;

template < typename _Tp >
struct owner_less ;

template < typename _Tp >
class enable_shared_from_this ;

template < _Lock_policy _Lp = __default_lock_policy >
class __weak_count ;

template < _Lock_policy _Lp = __default_lock_policy >
class __shared_count ;



template < typename _Ptr , _Lock_policy _Lp >
class _Sp_counted_ptr final : public _Sp_counted_base < _Lp >
{
public :
explicit
_Sp_counted_ptr ( _Ptr __p )
: _M_ptr ( __p ) { }

virtual void
_M_dispose ( ) noexcept
{ delete _M_ptr ; }

virtual void
_M_destroy ( ) noexcept
{ delete this ; }

virtual void *
_M_get_deleter ( const std :: type_info & )
{ return 0 ; }

_Sp_counted_ptr ( const _Sp_counted_ptr & ) = delete ;
_Sp_counted_ptr & operator = ( const _Sp_counted_ptr & ) = delete ;

protected :
_Ptr _M_ptr ;
} ;

template < >
inline void
_Sp_counted_ptr < nullptr_t , _S_single > :: _M_dispose ( ) noexcept { }

template < >
inline void
_Sp_counted_ptr < nullptr_t , _S_mutex > :: _M_dispose ( ) noexcept { }

template < >
inline void
_Sp_counted_ptr < nullptr_t , _S_atomic > :: _M_dispose ( ) noexcept { }


template < typename _Ptr , typename _Deleter , typename _Alloc , _Lock_policy _Lp >
class _Sp_counted_deleter final : public _Sp_counted_base < _Lp >
{



struct _My_Deleter
: public _Alloc
{
_Deleter _M_del ;
_My_Deleter ( _Deleter __d , const _Alloc & __a )
: _Alloc ( __a ) , _M_del ( __d ) { }
} ;

public :

_Sp_counted_deleter ( _Ptr __p , _Deleter __d )
: _M_ptr ( __p ) , _M_del ( __d , _Alloc ( ) ) { }


_Sp_counted_deleter ( _Ptr __p , _Deleter __d , const _Alloc & __a )
: _M_ptr ( __p ) , _M_del ( __d , __a ) { }

~ _Sp_counted_deleter ( ) noexcept { }

virtual void
_M_dispose ( ) noexcept
{ _M_del . _M_del ( _M_ptr ) ; }

virtual void
_M_destroy ( ) noexcept
{
typedef typename allocator_traits < _Alloc > :: template
rebind_traits < _Sp_counted_deleter > _Alloc_traits ;
typename _Alloc_traits :: allocator_type __a ( _M_del ) ;
_Alloc_traits :: destroy ( __a , this ) ;
_Alloc_traits :: deallocate ( __a , this , 1 ) ;
}

virtual void *
_M_get_deleter ( const std :: type_info & __ti )
{



return 0 ;

}

protected :
_Ptr _M_ptr ;
_My_Deleter _M_del ;
} ;



struct _Sp_make_shared_tag { } ;

template < typename _Tp , typename _Alloc , _Lock_policy _Lp >
class _Sp_counted_ptr_inplace final : public _Sp_counted_base < _Lp >
{



struct _Impl
: public _Alloc
{
_Impl ( _Alloc __a ) : _Alloc ( __a ) , _M_ptr ( ) { }
_Tp * _M_ptr ;
} ;

public :
template < typename ... _Args >
_Sp_counted_ptr_inplace ( _Alloc __a , _Args && ... __args )
: _M_impl ( __a ) , _M_storage ( )
{
_M_impl . _M_ptr = static_cast < _Tp * > ( static_cast < void * > ( & _M_storage ) ) ;


allocator_traits < _Alloc > :: construct ( __a , _M_impl . _M_ptr ,
std :: forward < _Args > ( __args ) ... ) ;
}

~ _Sp_counted_ptr_inplace ( ) noexcept { }

virtual void
_M_dispose ( ) noexcept
{ allocator_traits < _Alloc > :: destroy ( _M_impl , _M_impl . _M_ptr ) ; }


virtual void
_M_destroy ( ) noexcept
{
typedef typename allocator_traits < _Alloc > :: template
rebind_traits < _Sp_counted_ptr_inplace > _Alloc_traits ;
typename _Alloc_traits :: allocator_type __a ( _M_impl ) ;
_Alloc_traits :: destroy ( __a , this ) ;
_Alloc_traits :: deallocate ( __a , this , 1 ) ;
}


virtual void *
_M_get_deleter ( const std :: type_info & __ti ) noexcept
{





return 0 ;

}

private :
_Impl _M_impl ;
typename aligned_storage < sizeof ( _Tp ) , alignment_of < _Tp > :: value > :: type
_M_storage ;
} ;

template < _Lock_policy _Lp >
class __shared_count
{
public :
constexpr __shared_count ( ) noexcept : _M_pi ( 0 )
{ }

template < typename _Ptr >
explicit
__shared_count ( _Ptr __p ) : _M_pi ( 0 )
{
try
{
_M_pi = new _Sp_counted_ptr < _Ptr , _Lp > ( __p ) ;
}
catch ( ... )
{
delete __p ;
throw ;
}
}

template < typename _Ptr , typename _Deleter >
__shared_count ( _Ptr __p , _Deleter __d )
: __shared_count ( __p , std :: move ( __d ) , allocator < int > ( ) )
{ }

template < typename _Ptr , typename _Deleter , typename _Alloc >
__shared_count ( _Ptr __p , _Deleter __d , _Alloc __a ) : _M_pi ( 0 )
{
typedef _Sp_counted_deleter < _Ptr , _Deleter , _Alloc , _Lp > _Sp_cd_type ;
typedef typename allocator_traits < _Alloc > :: template
rebind_traits < _Sp_cd_type > _Alloc_traits ;
typename _Alloc_traits :: allocator_type __a2 ( __a ) ;
_Sp_cd_type * __mem = 0 ;
try
{
__mem = _Alloc_traits :: allocate ( __a2 , 1 ) ;
_Alloc_traits :: construct ( __a2 , __mem ,
__p , std :: move ( __d ) , std :: move ( __a ) ) ;
_M_pi = __mem ;
}
catch ( ... )
{
__d ( __p ) ;
if ( __mem )
_Alloc_traits :: deallocate ( __a2 , __mem , 1 ) ;
throw ;
}
}

template < typename _Tp , typename _Alloc , typename ... _Args >
__shared_count ( _Sp_make_shared_tag , _Tp * , const _Alloc & __a ,
_Args && ... __args )
: _M_pi ( 0 )
{
typedef _Sp_counted_ptr_inplace < _Tp , _Alloc , _Lp > _Sp_cp_type ;
typedef typename allocator_traits < _Alloc > :: template
rebind_traits < _Sp_cp_type > _Alloc_traits ;
typename _Alloc_traits :: allocator_type __a2 ( __a ) ;
_Sp_cp_type * __mem = _Alloc_traits :: allocate ( __a2 , 1 ) ;
try
{
_Alloc_traits :: construct ( __a2 , __mem , std :: move ( __a ) ,
std :: forward < _Args > ( __args ) ... ) ;
_M_pi = __mem ;
}
catch ( ... )
{
_Alloc_traits :: deallocate ( __a2 , __mem , 1 ) ;
throw ;
}
}



template < typename _Tp >
explicit
__shared_count ( std :: auto_ptr < _Tp > && __r ) ;



template < typename _Tp , typename _Del >
explicit
__shared_count ( std :: unique_ptr < _Tp , _Del > && __r ) : _M_pi ( 0 )
{
using _Ptr = typename unique_ptr < _Tp , _Del > :: pointer ;
using _Del2 = typename conditional < is_reference < _Del > :: value ,
reference_wrapper < typename remove_reference < _Del > :: type > ,
_Del > :: type ;
using _Sp_cd_type
= _Sp_counted_deleter < _Ptr , _Del2 , allocator < void > , _Lp > ;
using _Alloc = allocator < _Sp_cd_type > ;
using _Alloc_traits = allocator_traits < _Alloc > ;
_Alloc __a ;
_Sp_cd_type * __mem = _Alloc_traits :: allocate ( __a , 1 ) ;
_Alloc_traits :: construct ( __a , __mem , __r . release ( ) ,
__r . get_deleter ( ) ) ;
_M_pi = __mem ;
}


explicit __shared_count ( const __weak_count < _Lp > & __r ) ;

~ __shared_count ( ) noexcept
{
if ( _M_pi != nullptr )
_M_pi -> _M_release ( ) ;
}

__shared_count ( const __shared_count & __r ) noexcept
: _M_pi ( __r . _M_pi )
{
if ( _M_pi != 0 )
_M_pi -> _M_add_ref_copy ( ) ;
}

__shared_count &
operator = ( const __shared_count & __r ) noexcept
{
_Sp_counted_base < _Lp > * __tmp = __r . _M_pi ;
if ( __tmp != _M_pi )
{
if ( __tmp != 0 )
__tmp -> _M_add_ref_copy ( ) ;
if ( _M_pi != 0 )
_M_pi -> _M_release ( ) ;
_M_pi = __tmp ;
}
return * this ;
}

void
_M_swap ( __shared_count & __r ) noexcept
{
_Sp_counted_base < _Lp > * __tmp = __r . _M_pi ;
__r . _M_pi = _M_pi ;
_M_pi = __tmp ;
}

long
_M_get_use_count ( ) const noexcept
{ return _M_pi != 0 ? _M_pi -> _M_get_use_count ( ) : 0 ; }

bool
_M_unique ( ) const noexcept
{ return this -> _M_get_use_count ( ) == 1 ; }

void *
_M_get_deleter ( const std :: type_info & __ti ) const noexcept
{ return _M_pi ? _M_pi -> _M_get_deleter ( __ti ) : 0 ; }

bool
_M_less ( const __shared_count & __rhs ) const noexcept
{ return std :: less < _Sp_counted_base < _Lp > * > ( ) ( this -> _M_pi , __rhs . _M_pi ) ; }

bool
_M_less ( const __weak_count < _Lp > & __rhs ) const noexcept
{ return std :: less < _Sp_counted_base < _Lp > * > ( ) ( this -> _M_pi , __rhs . _M_pi ) ; }


friend inline bool
operator == ( const __shared_count & __a , const __shared_count & __b ) noexcept
{ return __a . _M_pi == __b . _M_pi ; }

private :
friend class __weak_count < _Lp > ;

_Sp_counted_base < _Lp > * _M_pi ;
} ;


template < _Lock_policy _Lp >
class __weak_count
{
public :
constexpr __weak_count ( ) noexcept : _M_pi ( 0 )
{ }

__weak_count ( const __shared_count < _Lp > & __r ) noexcept
: _M_pi ( __r . _M_pi )
{
if ( _M_pi != 0 )
_M_pi -> _M_weak_add_ref ( ) ;
}

__weak_count ( const __weak_count < _Lp > & __r ) noexcept
: _M_pi ( __r . _M_pi )
{
if ( _M_pi != 0 )
_M_pi -> _M_weak_add_ref ( ) ;
}

~ __weak_count ( ) noexcept
{
if ( _M_pi != 0 )
_M_pi -> _M_weak_release ( ) ;
}

__weak_count < _Lp > &
operator = ( const __shared_count < _Lp > & __r ) noexcept
{
_Sp_counted_base < _Lp > * __tmp = __r . _M_pi ;
if ( __tmp != 0 )
__tmp -> _M_weak_add_ref ( ) ;
if ( _M_pi != 0 )
_M_pi -> _M_weak_release ( ) ;
_M_pi = __tmp ;
return * this ;
}

__weak_count < _Lp > &
operator = ( const __weak_count < _Lp > & __r ) noexcept
{
_Sp_counted_base < _Lp > * __tmp = __r . _M_pi ;
if ( __tmp != 0 )
__tmp -> _M_weak_add_ref ( ) ;
if ( _M_pi != 0 )
_M_pi -> _M_weak_release ( ) ;
_M_pi = __tmp ;
return * this ;
}

void
_M_swap ( __weak_count < _Lp > & __r ) noexcept
{
_Sp_counted_base < _Lp > * __tmp = __r . _M_pi ;
__r . _M_pi = _M_pi ;
_M_pi = __tmp ;
}

long
_M_get_use_count ( ) const noexcept
{ return _M_pi != 0 ? _M_pi -> _M_get_use_count ( ) : 0 ; }

bool
_M_less ( const __weak_count & __rhs ) const noexcept
{ return std :: less < _Sp_counted_base < _Lp > * > ( ) ( this -> _M_pi , __rhs . _M_pi ) ; }

bool
_M_less ( const __shared_count < _Lp > & __rhs ) const noexcept
{ return std :: less < _Sp_counted_base < _Lp > * > ( ) ( this -> _M_pi , __rhs . _M_pi ) ; }


friend inline bool
operator == ( const __weak_count & __a , const __weak_count & __b ) noexcept
{ return __a . _M_pi == __b . _M_pi ; }

private :
friend class __shared_count < _Lp > ;

_Sp_counted_base < _Lp > * _M_pi ;
} ;


template < _Lock_policy _Lp >
inline __shared_count < _Lp > :: __shared_count ( const __weak_count < _Lp > & __r )
: _M_pi ( __r . _M_pi )
{
if ( _M_pi != 0 )
_M_pi -> _M_add_ref_lock ( ) ;
else
__throw_bad_weak_ptr ( ) ;
}





template < _Lock_policy _Lp , typename _Tp1 , typename _Tp2 >
void
__enable_shared_from_this_helper ( const __shared_count < _Lp > & ,
const __enable_shared_from_this < _Tp1 ,
_Lp > * , const _Tp2 * ) noexcept ;


template < typename _Tp1 , typename _Tp2 >
void
__enable_shared_from_this_helper ( const __shared_count < > & ,
const enable_shared_from_this < _Tp1 > * ,
const _Tp2 * ) noexcept ;

template < _Lock_policy _Lp >
inline void
__enable_shared_from_this_helper ( const __shared_count < _Lp > & , ... ) noexcept
{ }


template < typename _Tp , _Lock_policy _Lp >
class __shared_ptr
{
public :
typedef _Tp element_type ;

constexpr __shared_ptr ( ) noexcept
: _M_ptr ( 0 ) , _M_refcount ( )
{ }

template < typename _Tp1 >
explicit __shared_ptr ( _Tp1 * __p )
: _M_ptr ( __p ) , _M_refcount ( __p )
{

static_assert ( sizeof ( _Tp1 ) > 0 , "incomplete type" ) ;
__enable_shared_from_this_helper ( _M_refcount , __p , __p ) ;
}

template < typename _Tp1 , typename _Deleter >
__shared_ptr ( _Tp1 * __p , _Deleter __d )
: _M_ptr ( __p ) , _M_refcount ( __p , __d )
{


__enable_shared_from_this_helper ( _M_refcount , __p , __p ) ;
}

template < typename _Tp1 , typename _Deleter , typename _Alloc >
__shared_ptr ( _Tp1 * __p , _Deleter __d , _Alloc __a )
: _M_ptr ( __p ) , _M_refcount ( __p , __d , std :: move ( __a ) )
{


__enable_shared_from_this_helper ( _M_refcount , __p , __p ) ;
}

template < typename _Deleter >
__shared_ptr ( nullptr_t __p , _Deleter __d )
: _M_ptr ( 0 ) , _M_refcount ( __p , __d )
{ }

template < typename _Deleter , typename _Alloc >
__shared_ptr ( nullptr_t __p , _Deleter __d , _Alloc __a )
: _M_ptr ( 0 ) , _M_refcount ( __p , __d , std :: move ( __a ) )
{ }

template < typename _Tp1 >
__shared_ptr ( const __shared_ptr < _Tp1 , _Lp > & __r , _Tp * __p ) noexcept
: _M_ptr ( __p ) , _M_refcount ( __r . _M_refcount )
{ }

__shared_ptr ( const __shared_ptr & ) noexcept = default ;
__shared_ptr & operator = ( const __shared_ptr & ) noexcept = default ;
~ __shared_ptr ( ) = default ;

template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
__shared_ptr ( const __shared_ptr < _Tp1 , _Lp > & __r ) noexcept
: _M_ptr ( __r . _M_ptr ) , _M_refcount ( __r . _M_refcount )
{ }

__shared_ptr ( __shared_ptr && __r ) noexcept
: _M_ptr ( __r . _M_ptr ) , _M_refcount ( )
{
_M_refcount . _M_swap ( __r . _M_refcount ) ;
__r . _M_ptr = 0 ;
}

template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
__shared_ptr ( __shared_ptr < _Tp1 , _Lp > && __r ) noexcept
: _M_ptr ( __r . _M_ptr ) , _M_refcount ( )
{
_M_refcount . _M_swap ( __r . _M_refcount ) ;
__r . _M_ptr = 0 ;
}

template < typename _Tp1 >
explicit __shared_ptr ( const __weak_ptr < _Tp1 , _Lp > & __r )
: _M_refcount ( __r . _M_refcount )
{




_M_ptr = __r . _M_ptr ;
}


template < typename _Tp1 , typename _Del >
__shared_ptr ( std :: unique_ptr < _Tp1 , _Del > && __r )
: _M_ptr ( __r . get ( ) ) , _M_refcount ( )
{

auto __tmp = std :: __addressof ( * __r . get ( ) ) ;
_M_refcount = __shared_count < _Lp > ( std :: move ( __r ) ) ;
__enable_shared_from_this_helper ( _M_refcount , __tmp , __tmp ) ;
}



template < typename _Tp1 >
__shared_ptr ( std :: auto_ptr < _Tp1 > && __r ) ;



constexpr __shared_ptr ( nullptr_t ) noexcept
: _M_ptr ( 0 ) , _M_refcount ( )
{ }

template < typename _Tp1 >
__shared_ptr &
operator = ( const __shared_ptr < _Tp1 , _Lp > & __r ) noexcept
{
_M_ptr = __r . _M_ptr ;
_M_refcount = __r . _M_refcount ;
return * this ;
}


template < typename _Tp1 >
__shared_ptr &
operator = ( std :: auto_ptr < _Tp1 > && __r )
{
__shared_ptr ( std :: move ( __r ) ) . swap ( * this ) ;
return * this ;
}


__shared_ptr &
operator = ( __shared_ptr && __r ) noexcept
{
__shared_ptr ( std :: move ( __r ) ) . swap ( * this ) ;
return * this ;
}

template < class _Tp1 >
__shared_ptr &
operator = ( __shared_ptr < _Tp1 , _Lp > && __r ) noexcept
{
__shared_ptr ( std :: move ( __r ) ) . swap ( * this ) ;
return * this ;
}

template < typename _Tp1 , typename _Del >
__shared_ptr &
operator = ( std :: unique_ptr < _Tp1 , _Del > && __r )
{
__shared_ptr ( std :: move ( __r ) ) . swap ( * this ) ;
return * this ;
}

void
reset ( ) noexcept
{ __shared_ptr ( ) . swap ( * this ) ; }

template < typename _Tp1 >
void
reset ( _Tp1 * __p )
{

;
__shared_ptr ( __p ) . swap ( * this ) ;
}

template < typename _Tp1 , typename _Deleter >
void
reset ( _Tp1 * __p , _Deleter __d )
{ __shared_ptr ( __p , __d ) . swap ( * this ) ; }

template < typename _Tp1 , typename _Deleter , typename _Alloc >
void
reset ( _Tp1 * __p , _Deleter __d , _Alloc __a )
{ __shared_ptr ( __p , __d , std :: move ( __a ) ) . swap ( * this ) ; }


typename std :: add_lvalue_reference < _Tp > :: type
operator * ( ) const noexcept
{
;
return * _M_ptr ;
}

_Tp *
operator -> ( ) const noexcept
{
;
return _M_ptr ;
}

_Tp *
get ( ) const noexcept
{ return _M_ptr ; }

explicit operator bool ( ) const
{ return _M_ptr == 0 ? false : true ; }

bool
unique ( ) const noexcept
{ return _M_refcount . _M_unique ( ) ; }

long
use_count ( ) const noexcept
{ return _M_refcount . _M_get_use_count ( ) ; }

void
swap ( __shared_ptr < _Tp , _Lp > & __other ) noexcept
{
std :: swap ( _M_ptr , __other . _M_ptr ) ;
_M_refcount . _M_swap ( __other . _M_refcount ) ;
}

template < typename _Tp1 >
bool
owner_before ( __shared_ptr < _Tp1 , _Lp > const & __rhs ) const
{ return _M_refcount . _M_less ( __rhs . _M_refcount ) ; }

template < typename _Tp1 >
bool
owner_before ( __weak_ptr < _Tp1 , _Lp > const & __rhs ) const
{ return _M_refcount . _M_less ( __rhs . _M_refcount ) ; }
#966
template < typename _Alloc >
struct _Deleter
{
void operator ( ) ( _Tp * __ptr )
{
typedef allocator_traits < _Alloc > _Alloc_traits ;
_Alloc_traits :: destroy ( _M_alloc , __ptr ) ;
_Alloc_traits :: deallocate ( _M_alloc , __ptr , 1 ) ;
}
_Alloc _M_alloc ;
} ;

template < typename _Alloc , typename ... _Args >
__shared_ptr ( _Sp_make_shared_tag __tag , const _Alloc & __a ,
_Args && ... __args )
: _M_ptr ( ) , _M_refcount ( )
{
typedef typename _Alloc :: template rebind < _Tp > :: other _Alloc2 ;
_Deleter < _Alloc2 > __del = { _Alloc2 ( __a ) } ;
typedef allocator_traits < _Alloc2 > __traits ;
_M_ptr = __traits :: allocate ( __del . _M_alloc , 1 ) ;
try
{


__traits :: construct ( __del . _M_alloc , _M_ptr ,
std :: forward < _Args > ( __args ) ... ) ;
}
catch ( ... )
{
__traits :: deallocate ( __del . _M_alloc , _M_ptr , 1 ) ;
throw ;
}
__shared_count < _Lp > __count ( _M_ptr , __del , __del . _M_alloc ) ;
_M_refcount . _M_swap ( __count ) ;
__enable_shared_from_this_helper ( _M_refcount , _M_ptr , _M_ptr ) ;
}


template < typename _Tp1 , _Lock_policy _Lp1 , typename _Alloc ,
typename ... _Args >
friend __shared_ptr < _Tp1 , _Lp1 >
__allocate_shared ( const _Alloc & __a , _Args && ... __args ) ;

private :
void *
_M_get_deleter ( const std :: type_info & __ti ) const noexcept
{ return _M_refcount . _M_get_deleter ( __ti ) ; }

template < typename _Tp1 , _Lock_policy _Lp1 > friend class __shared_ptr ;
template < typename _Tp1 , _Lock_policy _Lp1 > friend class __weak_ptr ;

template < typename _Del , typename _Tp1 , _Lock_policy _Lp1 >
friend _Del * get_deleter ( const __shared_ptr < _Tp1 , _Lp1 > & ) noexcept ;

_Tp * _M_ptr ;
__shared_count < _Lp > _M_refcount ;
} ;



template < typename _Tp1 , typename _Tp2 , _Lock_policy _Lp >
inline bool
operator == ( const __shared_ptr < _Tp1 , _Lp > & __a ,
const __shared_ptr < _Tp2 , _Lp > & __b ) noexcept
{ return __a . get ( ) == __b . get ( ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator == ( const __shared_ptr < _Tp , _Lp > & __a , nullptr_t ) noexcept
{ return ! __a ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator == ( nullptr_t , const __shared_ptr < _Tp , _Lp > & __a ) noexcept
{ return ! __a ; }

template < typename _Tp1 , typename _Tp2 , _Lock_policy _Lp >
inline bool
operator != ( const __shared_ptr < _Tp1 , _Lp > & __a ,
const __shared_ptr < _Tp2 , _Lp > & __b ) noexcept
{ return __a . get ( ) != __b . get ( ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator != ( const __shared_ptr < _Tp , _Lp > & __a , nullptr_t ) noexcept
{ return ( bool ) __a ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator != ( nullptr_t , const __shared_ptr < _Tp , _Lp > & __a ) noexcept
{ return ( bool ) __a ; }

template < typename _Tp1 , typename _Tp2 , _Lock_policy _Lp >
inline bool
operator < ( const __shared_ptr < _Tp1 , _Lp > & __a ,
const __shared_ptr < _Tp2 , _Lp > & __b ) noexcept
{
typedef typename std :: common_type < _Tp1 * , _Tp2 * > :: type _CT ;
return std :: less < _CT > ( ) ( __a . get ( ) , __b . get ( ) ) ;
}

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator < ( const __shared_ptr < _Tp , _Lp > & __a , nullptr_t ) noexcept
{ return std :: less < _Tp * > ( ) ( __a . get ( ) , nullptr ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator < ( nullptr_t , const __shared_ptr < _Tp , _Lp > & __a ) noexcept
{ return std :: less < _Tp * > ( ) ( nullptr , __a . get ( ) ) ; }

template < typename _Tp1 , typename _Tp2 , _Lock_policy _Lp >
inline bool
operator <= ( const __shared_ptr < _Tp1 , _Lp > & __a ,
const __shared_ptr < _Tp2 , _Lp > & __b ) noexcept
{ return ! ( __b < __a ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator <= ( const __shared_ptr < _Tp , _Lp > & __a , nullptr_t ) noexcept
{ return ! ( nullptr < __a ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator <= ( nullptr_t , const __shared_ptr < _Tp , _Lp > & __a ) noexcept
{ return ! ( __a < nullptr ) ; }

template < typename _Tp1 , typename _Tp2 , _Lock_policy _Lp >
inline bool
operator > ( const __shared_ptr < _Tp1 , _Lp > & __a ,
const __shared_ptr < _Tp2 , _Lp > & __b ) noexcept
{ return ( __b < __a ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator > ( const __shared_ptr < _Tp , _Lp > & __a , nullptr_t ) noexcept
{ return std :: less < _Tp * > ( ) ( nullptr , __a . get ( ) ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator > ( nullptr_t , const __shared_ptr < _Tp , _Lp > & __a ) noexcept
{ return std :: less < _Tp * > ( ) ( __a . get ( ) , nullptr ) ; }

template < typename _Tp1 , typename _Tp2 , _Lock_policy _Lp >
inline bool
operator >= ( const __shared_ptr < _Tp1 , _Lp > & __a ,
const __shared_ptr < _Tp2 , _Lp > & __b ) noexcept
{ return ! ( __a < __b ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator >= ( const __shared_ptr < _Tp , _Lp > & __a , nullptr_t ) noexcept
{ return ! ( __a < nullptr ) ; }

template < typename _Tp , _Lock_policy _Lp >
inline bool
operator >= ( nullptr_t , const __shared_ptr < _Tp , _Lp > & __a ) noexcept
{ return ! ( nullptr < __a ) ; }

template < typename _Sp >
struct _Sp_less : public binary_function < _Sp , _Sp , bool >
{
bool
operator ( ) ( const _Sp & __lhs , const _Sp & __rhs ) const noexcept
{
typedef typename _Sp :: element_type element_type ;
return std :: less < element_type * > ( ) ( __lhs . get ( ) , __rhs . get ( ) ) ;
}
} ;

template < typename _Tp , _Lock_policy _Lp >
struct less < __shared_ptr < _Tp , _Lp >>
: public _Sp_less < __shared_ptr < _Tp , _Lp >>
{ } ;


template < typename _Tp , _Lock_policy _Lp >
inline void
swap ( __shared_ptr < _Tp , _Lp > & __a , __shared_ptr < _Tp , _Lp > & __b ) noexcept
{ __a . swap ( __b ) ; }
#1155
template < typename _Tp , typename _Tp1 , _Lock_policy _Lp >
inline __shared_ptr < _Tp , _Lp >
static_pointer_cast ( const __shared_ptr < _Tp1 , _Lp > & __r ) noexcept
{ return __shared_ptr < _Tp , _Lp > ( __r , static_cast < _Tp * > ( __r . get ( ) ) ) ; }
#1165
template < typename _Tp , typename _Tp1 , _Lock_policy _Lp >
inline __shared_ptr < _Tp , _Lp >
const_pointer_cast ( const __shared_ptr < _Tp1 , _Lp > & __r ) noexcept
{ return __shared_ptr < _Tp , _Lp > ( __r , const_cast < _Tp * > ( __r . get ( ) ) ) ; }
#1175
template < typename _Tp , typename _Tp1 , _Lock_policy _Lp >
inline __shared_ptr < _Tp , _Lp >
dynamic_pointer_cast ( const __shared_ptr < _Tp1 , _Lp > & __r ) noexcept
{
if ( _Tp * __p = dynamic_cast < _Tp * > ( __r . get ( ) ) )
return __shared_ptr < _Tp , _Lp > ( __r , __p ) ;
return __shared_ptr < _Tp , _Lp > ( ) ;
}


template < typename _Tp , _Lock_policy _Lp >
class __weak_ptr
{
public :
typedef _Tp element_type ;

constexpr __weak_ptr ( ) noexcept
: _M_ptr ( 0 ) , _M_refcount ( )
{ }

__weak_ptr ( const __weak_ptr & ) noexcept = default ;
__weak_ptr & operator = ( const __weak_ptr & ) noexcept = default ;
~ __weak_ptr ( ) = default ;
#1213
template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
__weak_ptr ( const __weak_ptr < _Tp1 , _Lp > & __r ) noexcept
: _M_refcount ( __r . _M_refcount )
{ _M_ptr = __r . lock ( ) . get ( ) ; }

template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
__weak_ptr ( const __shared_ptr < _Tp1 , _Lp > & __r ) noexcept
: _M_ptr ( __r . _M_ptr ) , _M_refcount ( __r . _M_refcount )
{ }

template < typename _Tp1 >
__weak_ptr &
operator = ( const __weak_ptr < _Tp1 , _Lp > & __r ) noexcept
{
_M_ptr = __r . lock ( ) . get ( ) ;
_M_refcount = __r . _M_refcount ;
return * this ;
}

template < typename _Tp1 >
__weak_ptr &
operator = ( const __shared_ptr < _Tp1 , _Lp > & __r ) noexcept
{
_M_ptr = __r . _M_ptr ;
_M_refcount = __r . _M_refcount ;
return * this ;
}

__shared_ptr < _Tp , _Lp >
lock ( ) const noexcept
{


if ( expired ( ) )
return __shared_ptr < element_type , _Lp > ( ) ;

try
{
return __shared_ptr < element_type , _Lp > ( * this ) ;
}
catch ( const bad_weak_ptr & )
{



return __shared_ptr < element_type , _Lp > ( ) ;
}
#1269
}

long
use_count ( ) const noexcept
{ return _M_refcount . _M_get_use_count ( ) ; }

bool
expired ( ) const noexcept
{ return _M_refcount . _M_get_use_count ( ) == 0 ; }

template < typename _Tp1 >
bool
owner_before ( const __shared_ptr < _Tp1 , _Lp > & __rhs ) const
{ return _M_refcount . _M_less ( __rhs . _M_refcount ) ; }

template < typename _Tp1 >
bool
owner_before ( const __weak_ptr < _Tp1 , _Lp > & __rhs ) const
{ return _M_refcount . _M_less ( __rhs . _M_refcount ) ; }

void
reset ( ) noexcept
{ __weak_ptr ( ) . swap ( * this ) ; }

void
swap ( __weak_ptr & __s ) noexcept
{
std :: swap ( _M_ptr , __s . _M_ptr ) ;
_M_refcount . _M_swap ( __s . _M_refcount ) ;
}

private :

void
_M_assign ( _Tp * __ptr , const __shared_count < _Lp > & __refcount ) noexcept
{
_M_ptr = __ptr ;
_M_refcount = __refcount ;
}

template < typename _Tp1 , _Lock_policy _Lp1 > friend class __shared_ptr ;
template < typename _Tp1 , _Lock_policy _Lp1 > friend class __weak_ptr ;
friend class __enable_shared_from_this < _Tp , _Lp > ;
friend class enable_shared_from_this < _Tp > ;

_Tp * _M_ptr ;
__weak_count < _Lp > _M_refcount ;
} ;


template < typename _Tp , _Lock_policy _Lp >
inline void
swap ( __weak_ptr < _Tp , _Lp > & __a , __weak_ptr < _Tp , _Lp > & __b ) noexcept
{ __a . swap ( __b ) ; }

template < typename _Tp , typename _Tp1 >
struct _Sp_owner_less : public binary_function < _Tp , _Tp , bool >
{
bool
operator ( ) ( const _Tp & __lhs , const _Tp & __rhs ) const
{ return __lhs . owner_before ( __rhs ) ; }

bool
operator ( ) ( const _Tp & __lhs , const _Tp1 & __rhs ) const
{ return __lhs . owner_before ( __rhs ) ; }

bool
operator ( ) ( const _Tp1 & __lhs , const _Tp & __rhs ) const
{ return __lhs . owner_before ( __rhs ) ; }
} ;

template < typename _Tp , _Lock_policy _Lp >
struct owner_less < __shared_ptr < _Tp , _Lp >>
: public _Sp_owner_less < __shared_ptr < _Tp , _Lp > , __weak_ptr < _Tp , _Lp >>
{ } ;

template < typename _Tp , _Lock_policy _Lp >
struct owner_less < __weak_ptr < _Tp , _Lp >>
: public _Sp_owner_less < __weak_ptr < _Tp , _Lp > , __shared_ptr < _Tp , _Lp >>
{ } ;


template < typename _Tp , _Lock_policy _Lp >
class __enable_shared_from_this
{
protected :
constexpr __enable_shared_from_this ( ) noexcept { }

__enable_shared_from_this ( const __enable_shared_from_this & ) noexcept { }

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

~ __enable_shared_from_this ( ) { }

public :
__shared_ptr < _Tp , _Lp >
shared_from_this ( )
{ return __shared_ptr < _Tp , _Lp > ( this -> _M_weak_this ) ; }

__shared_ptr < const _Tp , _Lp >
shared_from_this ( ) const
{ return __shared_ptr < const _Tp , _Lp > ( this -> _M_weak_this ) ; }

private :
template < typename _Tp1 >
void
_M_weak_assign ( _Tp1 * __p , const __shared_count < _Lp > & __n ) const noexcept
{ _M_weak_this . _M_assign ( __p , __n ) ; }

template < typename _Tp1 >
friend void
__enable_shared_from_this_helper ( const __shared_count < _Lp > & __pn ,
const __enable_shared_from_this * __pe ,
const _Tp1 * __px ) noexcept
{
if ( __pe != 0 )
__pe -> _M_weak_assign ( const_cast < _Tp1 * > ( __px ) , __pn ) ;
}

mutable __weak_ptr < _Tp , _Lp > _M_weak_this ;
} ;


template < typename _Tp , _Lock_policy _Lp , typename _Alloc , typename ... _Args >
inline __shared_ptr < _Tp , _Lp >
__allocate_shared ( const _Alloc & __a , _Args && ... __args )
{
return __shared_ptr < _Tp , _Lp > ( _Sp_make_shared_tag ( ) , __a ,
std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , _Lock_policy _Lp , typename ... _Args >
inline __shared_ptr < _Tp , _Lp >
__make_shared ( _Args && ... __args )
{
typedef typename std :: remove_const < _Tp > :: type _Tp_nc ;
return std :: __allocate_shared < _Tp , _Lp > ( std :: allocator < _Tp_nc > ( ) ,
std :: forward < _Args > ( __args ) ... ) ;
}


template < typename _Tp , _Lock_policy _Lp >
struct hash < __shared_ptr < _Tp , _Lp >>
: public __hash_base < size_t , __shared_ptr < _Tp , _Lp >>
{
size_t
operator ( ) ( const __shared_ptr < _Tp , _Lp > & __s ) const noexcept
{ return std :: hash < _Tp * > ( ) ( __s . get ( ) ) ; }
} ;


}
#54 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/shared_ptr.h"
namespace std
{
#64
template < typename _Ch , typename _Tr , typename _Tp , _Lock_policy _Lp >
inline std :: basic_ostream < _Ch , _Tr > &
operator << ( std :: basic_ostream < _Ch , _Tr > & __os ,
const __shared_ptr < _Tp , _Lp > & __p )
{
__os << __p . get ( ) ;
return __os ;
}


template < typename _Del , typename _Tp , _Lock_policy _Lp >
inline _Del *
get_deleter ( const __shared_ptr < _Tp , _Lp > & __p ) noexcept
{



return 0 ;

}
#92
template < typename _Tp >
class shared_ptr : public __shared_ptr < _Tp >
{
public :




constexpr shared_ptr ( ) noexcept
: __shared_ptr < _Tp > ( ) { }

shared_ptr ( const shared_ptr & ) noexcept = default ;
#111
template < typename _Tp1 >
explicit shared_ptr ( _Tp1 * __p )
: __shared_ptr < _Tp > ( __p ) { }
#128
template < typename _Tp1 , typename _Deleter >
shared_ptr ( _Tp1 * __p , _Deleter __d )
: __shared_ptr < _Tp > ( __p , __d ) { }
#145
template < typename _Deleter >
shared_ptr ( nullptr_t __p , _Deleter __d )
: __shared_ptr < _Tp > ( __p , __d ) { }
#164
template < typename _Tp1 , typename _Deleter , typename _Alloc >
shared_ptr ( _Tp1 * __p , _Deleter __d , _Alloc __a )
: __shared_ptr < _Tp > ( __p , __d , std :: move ( __a ) ) { }
#183
template < typename _Deleter , typename _Alloc >
shared_ptr ( nullptr_t __p , _Deleter __d , _Alloc __a )
: __shared_ptr < _Tp > ( __p , __d , std :: move ( __a ) ) { }
#205
template < typename _Tp1 >
shared_ptr ( const shared_ptr < _Tp1 > & __r , _Tp * __p ) noexcept
: __shared_ptr < _Tp > ( __r , __p ) { }
#216
template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
shared_ptr ( const shared_ptr < _Tp1 > & __r ) noexcept
: __shared_ptr < _Tp > ( __r ) { }
#226
shared_ptr ( shared_ptr && __r ) noexcept
: __shared_ptr < _Tp > ( std :: move ( __r ) ) { }
#234
template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
shared_ptr ( shared_ptr < _Tp1 > && __r ) noexcept
: __shared_ptr < _Tp > ( std :: move ( __r ) ) { }
#247
template < typename _Tp1 >
explicit shared_ptr ( const weak_ptr < _Tp1 > & __r )
: __shared_ptr < _Tp > ( __r ) { }


template < typename _Tp1 >
shared_ptr ( std :: auto_ptr < _Tp1 > && __r ) ;


template < typename _Tp1 , typename _Del >
shared_ptr ( std :: unique_ptr < _Tp1 , _Del > && __r )
: __shared_ptr < _Tp > ( std :: move ( __r ) ) { }
#265
constexpr shared_ptr ( nullptr_t __p ) noexcept
: __shared_ptr < _Tp > ( __p ) { }

shared_ptr & operator = ( const shared_ptr & ) noexcept = default ;

template < typename _Tp1 >
shared_ptr &
operator = ( const shared_ptr < _Tp1 > & __r ) noexcept
{
this -> __shared_ptr < _Tp > :: operator = ( __r ) ;
return * this ;
}


template < typename _Tp1 >
shared_ptr &
operator = ( std :: auto_ptr < _Tp1 > && __r )
{
this -> __shared_ptr < _Tp > :: operator = ( std :: move ( __r ) ) ;
return * this ;
}


shared_ptr &
operator = ( shared_ptr && __r ) noexcept
{
this -> __shared_ptr < _Tp > :: operator = ( std :: move ( __r ) ) ;
return * this ;
}

template < class _Tp1 >
shared_ptr &
operator = ( shared_ptr < _Tp1 > && __r ) noexcept
{
this -> __shared_ptr < _Tp > :: operator = ( std :: move ( __r ) ) ;
return * this ;
}

template < typename _Tp1 , typename _Del >
shared_ptr &
operator = ( std :: unique_ptr < _Tp1 , _Del > && __r )
{
this -> __shared_ptr < _Tp > :: operator = ( std :: move ( __r ) ) ;
return * this ;
}

private :

template < typename _Alloc , typename ... _Args >
shared_ptr ( _Sp_make_shared_tag __tag , const _Alloc & __a ,
_Args && ... __args )
: __shared_ptr < _Tp > ( __tag , __a , std :: forward < _Args > ( __args ) ... )
{ }

template < typename _Tp1 , typename _Alloc , typename ... _Args >
friend shared_ptr < _Tp1 >
allocate_shared ( const _Alloc & __a , _Args && ... __args ) ;
} ;


template < typename _Tp1 , typename _Tp2 >
inline bool
operator == ( const shared_ptr < _Tp1 > & __a ,
const shared_ptr < _Tp2 > & __b ) noexcept
{ return __a . get ( ) == __b . get ( ) ; }

template < typename _Tp >
inline bool
operator == ( const shared_ptr < _Tp > & __a , nullptr_t ) noexcept
{ return ! __a ; }

template < typename _Tp >
inline bool
operator == ( nullptr_t , const shared_ptr < _Tp > & __a ) noexcept
{ return ! __a ; }

template < typename _Tp1 , typename _Tp2 >
inline bool
operator != ( const shared_ptr < _Tp1 > & __a ,
const shared_ptr < _Tp2 > & __b ) noexcept
{ return __a . get ( ) != __b . get ( ) ; }

template < typename _Tp >
inline bool
operator != ( const shared_ptr < _Tp > & __a , nullptr_t ) noexcept
{ return ( bool ) __a ; }

template < typename _Tp >
inline bool
operator != ( nullptr_t , const shared_ptr < _Tp > & __a ) noexcept
{ return ( bool ) __a ; }

template < typename _Tp1 , typename _Tp2 >
inline bool
operator < ( const shared_ptr < _Tp1 > & __a ,
const shared_ptr < _Tp2 > & __b ) noexcept
{
typedef typename std :: common_type < _Tp1 * , _Tp2 * > :: type _CT ;
return std :: less < _CT > ( ) ( __a . get ( ) , __b . get ( ) ) ;
}

template < typename _Tp >
inline bool
operator < ( const shared_ptr < _Tp > & __a , nullptr_t ) noexcept
{ return std :: less < _Tp * > ( ) ( __a . get ( ) , nullptr ) ; }

template < typename _Tp >
inline bool
operator < ( nullptr_t , const shared_ptr < _Tp > & __a ) noexcept
{ return std :: less < _Tp * > ( ) ( nullptr , __a . get ( ) ) ; }

template < typename _Tp1 , typename _Tp2 >
inline bool
operator <= ( const shared_ptr < _Tp1 > & __a ,
const shared_ptr < _Tp2 > & __b ) noexcept
{ return ! ( __b < __a ) ; }

template < typename _Tp >
inline bool
operator <= ( const shared_ptr < _Tp > & __a , nullptr_t ) noexcept
{ return ! ( nullptr < __a ) ; }

template < typename _Tp >
inline bool
operator <= ( nullptr_t , const shared_ptr < _Tp > & __a ) noexcept
{ return ! ( __a < nullptr ) ; }

template < typename _Tp1 , typename _Tp2 >
inline bool
operator > ( const shared_ptr < _Tp1 > & __a ,
const shared_ptr < _Tp2 > & __b ) noexcept
{ return ( __b < __a ) ; }

template < typename _Tp >
inline bool
operator > ( const shared_ptr < _Tp > & __a , nullptr_t ) noexcept
{ return std :: less < _Tp * > ( ) ( nullptr , __a . get ( ) ) ; }

template < typename _Tp >
inline bool
operator > ( nullptr_t , const shared_ptr < _Tp > & __a ) noexcept
{ return std :: less < _Tp * > ( ) ( __a . get ( ) , nullptr ) ; }

template < typename _Tp1 , typename _Tp2 >
inline bool
operator >= ( const shared_ptr < _Tp1 > & __a ,
const shared_ptr < _Tp2 > & __b ) noexcept
{ return ! ( __a < __b ) ; }

template < typename _Tp >
inline bool
operator >= ( const shared_ptr < _Tp > & __a , nullptr_t ) noexcept
{ return ! ( __a < nullptr ) ; }

template < typename _Tp >
inline bool
operator >= ( nullptr_t , const shared_ptr < _Tp > & __a ) noexcept
{ return ! ( nullptr < __a ) ; }

template < typename _Tp >
struct less < shared_ptr < _Tp >> : public _Sp_less < shared_ptr < _Tp >>
{ } ;


template < typename _Tp >
inline void
swap ( shared_ptr < _Tp > & __a , shared_ptr < _Tp > & __b ) noexcept
{ __a . swap ( __b ) ; }


template < typename _Tp , typename _Tp1 >
inline shared_ptr < _Tp >
static_pointer_cast ( const shared_ptr < _Tp1 > & __r ) noexcept
{ return shared_ptr < _Tp > ( __r , static_cast < _Tp * > ( __r . get ( ) ) ) ; }

template < typename _Tp , typename _Tp1 >
inline shared_ptr < _Tp >
const_pointer_cast ( const shared_ptr < _Tp1 > & __r ) noexcept
{ return shared_ptr < _Tp > ( __r , const_cast < _Tp * > ( __r . get ( ) ) ) ; }

template < typename _Tp , typename _Tp1 >
inline shared_ptr < _Tp >
dynamic_pointer_cast ( const shared_ptr < _Tp1 > & __r ) noexcept
{
if ( _Tp * __p = dynamic_cast < _Tp * > ( __r . get ( ) ) )
return shared_ptr < _Tp > ( __r , __p ) ;
return shared_ptr < _Tp > ( ) ;
}
#460
template < typename _Tp >
class weak_ptr : public __weak_ptr < _Tp >
{
public :
constexpr weak_ptr ( ) noexcept
: __weak_ptr < _Tp > ( ) { }

template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
weak_ptr ( const weak_ptr < _Tp1 > & __r ) noexcept
: __weak_ptr < _Tp > ( __r ) { }

template < typename _Tp1 , typename = typename
std :: enable_if < std :: is_convertible < _Tp1 * , _Tp * > :: value > :: type >
weak_ptr ( const shared_ptr < _Tp1 > & __r ) noexcept
: __weak_ptr < _Tp > ( __r ) { }

template < typename _Tp1 >
weak_ptr &
operator = ( const weak_ptr < _Tp1 > & __r ) noexcept
{
this -> __weak_ptr < _Tp > :: operator = ( __r ) ;
return * this ;
}

template < typename _Tp1 >
weak_ptr &
operator = ( const shared_ptr < _Tp1 > & __r ) noexcept
{
this -> __weak_ptr < _Tp > :: operator = ( __r ) ;
return * this ;
}

shared_ptr < _Tp >
lock ( ) const noexcept
{

if ( this -> expired ( ) )
return shared_ptr < _Tp > ( ) ;

try
{
return shared_ptr < _Tp > ( * this ) ;
}
catch ( const bad_weak_ptr & )
{
return shared_ptr < _Tp > ( ) ;
}



}
} ;


template < typename _Tp >
inline void
swap ( weak_ptr < _Tp > & __a , weak_ptr < _Tp > & __b ) noexcept
{ __a . swap ( __b ) ; }



template < typename _Tp >
struct owner_less ;


template < typename _Tp >
struct owner_less < shared_ptr < _Tp >>
: public _Sp_owner_less < shared_ptr < _Tp > , weak_ptr < _Tp >>
{ } ;


template < typename _Tp >
struct owner_less < weak_ptr < _Tp >>
: public _Sp_owner_less < weak_ptr < _Tp > , shared_ptr < _Tp >>
{ } ;




template < typename _Tp >
class enable_shared_from_this
{
protected :
constexpr enable_shared_from_this ( ) noexcept { }

enable_shared_from_this ( const enable_shared_from_this & ) noexcept { }

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

~ enable_shared_from_this ( ) { }

public :
shared_ptr < _Tp >
shared_from_this ( )
{ return shared_ptr < _Tp > ( this -> _M_weak_this ) ; }

shared_ptr < const _Tp >
shared_from_this ( ) const
{ return shared_ptr < const _Tp > ( this -> _M_weak_this ) ; }

private :
template < typename _Tp1 >
void
_M_weak_assign ( _Tp1 * __p , const __shared_count < > & __n ) const noexcept
{ _M_weak_this . _M_assign ( __p , __n ) ; }

template < typename _Tp1 >
friend void
__enable_shared_from_this_helper ( const __shared_count < > & __pn ,
const enable_shared_from_this * __pe ,
const _Tp1 * __px ) noexcept
{
if ( __pe != 0 )
__pe -> _M_weak_assign ( const_cast < _Tp1 * > ( __px ) , __pn ) ;
}

mutable weak_ptr < _Tp > _M_weak_this ;
} ;
#593
template < typename _Tp , typename _Alloc , typename ... _Args >
inline shared_ptr < _Tp >
allocate_shared ( const _Alloc & __a , _Args && ... __args )
{
return shared_ptr < _Tp > ( _Sp_make_shared_tag ( ) , __a ,
std :: forward < _Args > ( __args ) ... ) ;
}
#608
template < typename _Tp , typename ... _Args >
inline shared_ptr < _Tp >
make_shared ( _Args && ... __args )
{
typedef typename std :: remove_const < _Tp > :: type _Tp_nc ;
return std :: allocate_shared < _Tp > ( std :: allocator < _Tp_nc > ( ) ,
std :: forward < _Args > ( __args ) ... ) ;
}


template < typename _Tp >
struct hash < shared_ptr < _Tp >>
: public __hash_base < size_t , shared_ptr < _Tp >>
{
size_t
operator ( ) ( const shared_ptr < _Tp > & __s ) const noexcept
{ return std :: hash < _Tp * > ( ) ( __s . get ( ) ) ; }
} ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/backward/auto_ptr.h"
#36
namespace std
{
#47
template < typename _Tp1 >
struct auto_ptr_ref
{
_Tp1 * _M_ptr ;

explicit
auto_ptr_ref ( _Tp1 * __p ) : _M_ptr ( __p ) { }
} __attribute__ ( ( __deprecated__ ) ) ;
#86
template < typename _Tp >
class auto_ptr
{
private :
_Tp * _M_ptr ;

public :

typedef _Tp element_type ;
#102
explicit
auto_ptr ( element_type * __p = 0 ) throw ( ) : _M_ptr ( __p ) { }
#112
auto_ptr ( auto_ptr & __a ) throw ( ) : _M_ptr ( __a . release ( ) ) { }
#124
template < typename _Tp1 >
auto_ptr ( auto_ptr < _Tp1 > & __a ) throw ( ) : _M_ptr ( __a . release ( ) ) { }
#135
auto_ptr &
operator = ( auto_ptr & __a ) throw ( )
{
reset ( __a . release ( ) ) ;
return * this ;
}
#152
template < typename _Tp1 >
auto_ptr &
operator = ( auto_ptr < _Tp1 > & __a ) throw ( )
{
reset ( __a . release ( ) ) ;
return * this ;
}
#170
~ auto_ptr ( ) { delete _M_ptr ; }
#180
element_type &
operator * ( ) const throw ( )
{
;
return * _M_ptr ;
}
#193
element_type *
operator -> ( ) const throw ( )
{
;
return _M_ptr ;
}
#210
element_type *
get ( ) const throw ( ) { return _M_ptr ; }
#224
element_type *
release ( ) throw ( )
{
element_type * __tmp = _M_ptr ;
_M_ptr = 0 ;
return __tmp ;
}
#239
void
reset ( element_type * __p = 0 ) throw ( )
{
if ( __p != _M_ptr )
{
delete _M_ptr ;
_M_ptr = __p ;
}
}
#260
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 ( ) ) ; }
} __attribute__ ( ( __deprecated__ ) ) ;



template < >
class auto_ptr < void >
{
public :
typedef void element_type ;
} __attribute__ ( ( __deprecated__ ) ) ;


template < _Lock_policy _Lp >
template < typename _Tp >
inline
__shared_count < _Lp > :: __shared_count ( std :: auto_ptr < _Tp > && __r )
: _M_pi ( new _Sp_counted_ptr < _Tp * , _Lp > ( __r . get ( ) ) )
{ __r . release ( ) ; }

template < typename _Tp , _Lock_policy _Lp >
template < typename _Tp1 >
inline
__shared_ptr < _Tp , _Lp > :: __shared_ptr ( std :: auto_ptr < _Tp1 > && __r )
: _M_ptr ( __r . get ( ) ) , _M_refcount ( )
{

static_assert ( sizeof ( _Tp1 ) > 0 , "incomplete type" ) ;
_Tp1 * __tmp = __r . get ( ) ;
_M_refcount = __shared_count < _Lp > ( std :: move ( __r ) ) ;
__enable_shared_from_this_helper ( _M_refcount , __tmp , __tmp ) ;
}

template < typename _Tp >
template < typename _Tp1 >
inline
shared_ptr < _Tp > :: shared_ptr ( std :: auto_ptr < _Tp1 > && __r )
: __shared_ptr < _Tp > ( std :: move ( __r ) ) { }

template < typename _Tp , typename _Dp >
template < typename _Up , typename >
inline
unique_ptr < _Tp , _Dp > :: unique_ptr ( auto_ptr < _Up > && __u ) noexcept
: _M_t ( __u . release ( ) , deleter_type ( ) ) { }



}
#24 "./boost/smart_ptr/scoped_ptr.hpp"
namespace boost
{
#41
template < class T > class scoped_ptr
{
private :

T * px ;

scoped_ptr ( scoped_ptr const & ) ;
scoped_ptr & operator = ( scoped_ptr const & ) ;

typedef scoped_ptr < T > this_type ;

void operator == ( scoped_ptr const & ) const ;
void operator != ( scoped_ptr const & ) const ;

public :

typedef T element_type ;

explicit scoped_ptr ( T * p = 0 ) : px ( p )
{



}



explicit scoped_ptr ( std :: auto_ptr < T > p ) : px ( p . release ( ) )
{



}



~ scoped_ptr ( )
{



boost :: checked_delete ( px ) ;
}

void reset ( T * p = 0 )
{
( ( void ) 0 ) ;
this_type ( p ) . swap ( * this ) ;
}

T & operator * ( ) const
{
( ( void ) 0 ) ;
return * px ;
}

T * operator -> ( ) const
{
( ( void ) 0 ) ;
return px ;
}

T * get ( ) const
{
return px ;
}
#1 "./boost/smart_ptr/detail/operator_bool.hpp"
#50
typedef element_type * this_type :: * unspecified_bool_type ;

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




bool operator ! ( ) const
{
return px == 0 ;
}
#111 "./boost/smart_ptr/scoped_ptr.hpp"
void swap ( scoped_ptr & b )
{
T * tmp = b . px ;
b . px = px ;
px = tmp ;
}
} ;
#143
template < class T > inline void swap ( scoped_ptr < T > & a , scoped_ptr < T > & b )
{
a . swap ( b ) ;
}



template < class T > inline T * get_pointer ( scoped_ptr < T > const & p )
{
return p . get ( ) ;
}

}
#1 "./boost/scoped_array.hpp"
#1 "./boost/smart_ptr/scoped_array.hpp"
#1 "./boost/assert.hpp"
#1 "/usr/include/assert.h"
#23 "./boost/smart_ptr/scoped_array.hpp"
namespace boost
{
#39
template < class T > class scoped_array
{
private :

T * px ;

scoped_array ( scoped_array const & ) ;
scoped_array & operator = ( scoped_array const & ) ;

typedef scoped_array < T > this_type ;

void operator == ( scoped_array const & ) const ;
void operator != ( scoped_array const & ) const ;

public :

typedef T element_type ;

explicit scoped_array ( T * p = 0 ) : px ( p )
{



}

~ scoped_array ( )
{



boost :: checked_array_delete ( px ) ;
}

void reset ( T * p = 0 )
{
( ( void ) 0 ) ;
this_type ( p ) . swap ( * this ) ;
}

T & operator [ ] ( std :: ptrdiff_t i ) const
{
( ( void ) 0 ) ;
( ( void ) 0 ) ;
return px [ i ] ;
}

T * get ( ) const
{
return px ;
}
#1 "./boost/smart_ptr/detail/operator_bool.hpp"
#50
typedef element_type * this_type :: * unspecified_bool_type ;

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




bool operator ! ( ) const
{
return px == 0 ;
}
#93 "./boost/smart_ptr/scoped_array.hpp"
void swap ( scoped_array & b )
{
T * tmp = b . px ;
b . px = px ;
px = tmp ;
}
} ;
#125
template < class T > inline void swap ( scoped_array < T > & a , scoped_array < T > & b )
{
a . swap ( b ) ;
}

}
#1 "./boost/shared_ptr.hpp"
#1 "./boost/smart_ptr/shared_ptr.hpp"
#1 "./boost/config/no_tr1/memory.hpp"
#1 "./boost/assert.hpp"
#1 "/usr/include/assert.h"
#1 "./boost/smart_ptr/detail/shared_count.hpp"
#1 "./boost/smart_ptr/bad_weak_ptr.hpp"
#26
namespace boost
{
#39
class bad_weak_ptr : public std :: exception
{
public :

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





}
#1 "./boost/smart_ptr/detail/sp_counted_base.hpp"
#1 "./boost/smart_ptr/detail/sp_has_sync.hpp"
#1 "./boost/smart_ptr/detail/sp_counted_base_spin.hpp"
#1 "./boost/detail/sp_typeinfo.hpp"
#111
namespace boost
{

namespace detail
{
#123
typedef std :: type_info sp_typeinfo ;



}

}
#1 "./boost/smart_ptr/detail/spinlock_pool.hpp"
#1 "./boost/smart_ptr/detail/spinlock.hpp"
#1 "./boost/smart_ptr/detail/spinlock_pt.hpp"
#20
namespace boost
{

namespace detail
{

class spinlock
{
public :

pthread_mutex_t v_ ;

public :

bool try_lock ( )
{
return pthread_mutex_trylock ( & v_ ) == 0 ;
}

void lock ( )
{
pthread_mutex_lock ( & v_ ) ;
}

void unlock ( )
{
pthread_mutex_unlock ( & v_ ) ;
}

public :

class scoped_lock
{
private :

spinlock & sp_ ;

scoped_lock ( scoped_lock const & ) ;
scoped_lock & operator = ( scoped_lock const & ) ;

public :

explicit scoped_lock ( spinlock & sp ) : sp_ ( sp )
{
sp . lock ( ) ;
}

~ scoped_lock ( )
{
sp_ . unlock ( ) ;
}
} ;
} ;

}
}
#28 "./boost/smart_ptr/detail/spinlock_pool.hpp"
namespace boost
{

namespace detail
{

template < int I > class spinlock_pool
{
private :

static spinlock pool_ [ 41 ] ;

public :

static spinlock & spinlock_for ( void const * pv )
{



std :: size_t i = reinterpret_cast < std :: size_t > ( pv ) % 41 ;

return pool_ [ i ] ;
}

class scoped_lock
{
private :

spinlock & sp_ ;

scoped_lock ( scoped_lock const & ) ;
scoped_lock & operator = ( scoped_lock const & ) ;

public :

explicit scoped_lock ( void const * pv ) : sp_ ( spinlock_for ( pv ) )
{
sp_ . lock ( ) ;
}

~ scoped_lock ( )
{
sp_ . unlock ( ) ;
}
} ;
} ;

template < int I > spinlock spinlock_pool < I > :: pool_ [ 41 ] =
{
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#77
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#77
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#78
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#78
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#79
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#79
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#80
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#80
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#81
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#81
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#82
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#82
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#83
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#83
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0
#84
, 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } } , { { { 0 , 0 , 0
#84
, 0 , 0x4d58 } , { { { 0 } } } , 0 } } ,
{ { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } }
} ;

}
}
#24 "./boost/smart_ptr/detail/sp_counted_base_spin.hpp"
namespace boost
{

namespace detail
{

inline int atomic_exchange_and_add ( int * pw , int dv )
{
spinlock_pool < 1 > :: scoped_lock lock ( pw ) ;

int r = * pw ;
* pw += dv ;
return r ;
}

inline void atomic_increment ( int * pw )
{
spinlock_pool < 1 > :: scoped_lock lock ( pw ) ;
++ * pw ;
}

inline int atomic_conditional_increment ( int * pw )
{
spinlock_pool < 1 > :: scoped_lock lock ( pw ) ;

int rv = * pw ;
if ( rv != 0 ) ++ * pw ;
return rv ;
}

class sp_counted_base
{
private :

sp_counted_base ( sp_counted_base const & ) ;
sp_counted_base & operator = ( sp_counted_base const & ) ;

int use_count_ ;
int weak_count_ ;

public :

sp_counted_base ( ) : use_count_ ( 1 ) , weak_count_ ( 1 )
{
}

virtual ~ sp_counted_base ( )
{
}




virtual void dispose ( ) = 0 ;



virtual void destroy ( )
{
delete this ;
}

virtual void * get_deleter ( sp_typeinfo const & ti ) = 0 ;
virtual void * get_untyped_deleter ( ) = 0 ;

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

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

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

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

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

long use_count ( ) const
{
spinlock_pool < 1 > :: scoped_lock lock ( & use_count_ ) ;
return use_count_ ;
}
} ;

}

}
#1 "./boost/smart_ptr/detail/sp_counted_impl.hpp"
#40
namespace boost
{
#50
namespace detail
{

template < class X > class sp_counted_impl_p : public sp_counted_base
{
private :

X * px_ ;

sp_counted_impl_p ( sp_counted_impl_p const & ) ;
sp_counted_impl_p & operator = ( sp_counted_impl_p const & ) ;

typedef sp_counted_impl_p < X > this_type ;

public :

explicit sp_counted_impl_p ( X * px ) : px_ ( px )
{



}

virtual void dispose ( )
{



boost :: checked_delete ( px_ ) ;
}

virtual void * get_deleter ( detail :: sp_typeinfo const & )
{
return 0 ;
}

virtual void * get_untyped_deleter ( )
{
return 0 ;
}
#118
} ;
#127
template < class P , class D > class sp_counted_impl_pd : public sp_counted_base
{
private :

P ptr ;
D del ;

sp_counted_impl_pd ( sp_counted_impl_pd const & ) ;
sp_counted_impl_pd & operator = ( sp_counted_impl_pd const & ) ;

typedef sp_counted_impl_pd < P , D > this_type ;

public :



sp_counted_impl_pd ( P p , D & d ) : ptr ( p ) , del ( d )
{
}

sp_counted_impl_pd ( P p ) : ptr ( p ) , del ( )
{
}

virtual void dispose ( )
{
del ( ptr ) ;
}

virtual void * get_deleter ( detail :: sp_typeinfo const & ti )
{
return ti == typeid ( D ) ? & reinterpret_cast < char & > ( del ) : 0 ;
}

virtual void * get_untyped_deleter ( )
{
return & reinterpret_cast < char & > ( del ) ;
}
#193
} ;

template < class P , class D , class A > class sp_counted_impl_pda : public sp_counted_base
{
private :

P p_ ;
D d_ ;
A a_ ;

sp_counted_impl_pda ( sp_counted_impl_pda const & ) ;
sp_counted_impl_pda & operator = ( sp_counted_impl_pda const & ) ;

typedef sp_counted_impl_pda < P , D , A > this_type ;

public :



sp_counted_impl_pda ( P p , D & d , A a ) : p_ ( p ) , d_ ( d ) , a_ ( a )
{
}

sp_counted_impl_pda ( P p , A a ) : p_ ( p ) , d_ ( ) , a_ ( a )
{
}

virtual void dispose ( )
{
d_ ( p_ ) ;
}

virtual void destroy ( )
{
typedef typename A :: template rebind < this_type > :: other A2 ;

A2 a2 ( a_ ) ;

this -> ~ this_type ( ) ;
a2 . deallocate ( this , 1 ) ;
}

virtual void * get_deleter ( detail :: sp_typeinfo const & ti )
{
return ti == typeid ( D ) ? & reinterpret_cast < char & > ( d_ ) : 0 ;
}

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





}

}
#47 "./boost/smart_ptr/detail/shared_count.hpp"
namespace boost
{

namespace detail
{
#60
struct sp_nothrow_tag { } ;

template < class D > struct sp_inplace_tag
{
} ;
#98
class weak_count ;

class shared_count
{
private :

sp_counted_base * pi_ ;





friend class weak_count ;

public :

shared_count ( ) : pi_ ( 0 )



{
}

template < class Y > explicit shared_count ( Y * p ) : pi_ ( 0 )



{


try
{
pi_ = new sp_counted_impl_p < Y > ( p ) ;
}
catch ( ... )
{
boost :: checked_delete ( p ) ;
throw ;
}
#149
}




template < class P , class D > shared_count ( P p , D d ) : pi_ ( 0 )




{





try
{
pi_ = new sp_counted_impl_pd < P , D > ( p , d ) ;
}
catch ( ... )
{
d ( p ) ;
throw ;
}
#186
}



template < class P , class D > shared_count ( P p , sp_inplace_tag < D > ) : pi_ ( 0 )



{


try
{
pi_ = new sp_counted_impl_pd < P , D > ( p ) ;
}
catch ( ... )
{
D :: operator_fn ( p ) ;
throw ;
}
#218
}



template < class P , class D , class A > shared_count ( P p , D d , A a ) : pi_ ( 0 )



{
typedef sp_counted_impl_pda < P , D , A > impl_type ;
typedef typename A :: template rebind < impl_type > :: other A2 ;

A2 a2 ( a ) ;



try
{
pi_ = a2 . allocate ( 1 , static_cast < impl_type * > ( 0 ) ) ;
new ( static_cast < void * > ( pi_ ) ) impl_type ( p , d , a ) ;
}
catch ( ... )
{
d ( p ) ;

if ( pi_ != 0 )
{
a2 . deallocate ( static_cast < impl_type * > ( pi_ ) , 1 ) ;
}

throw ;
}
#266
}



template < class P , class D , class A > shared_count ( P p , sp_inplace_tag < D > , A a ) : pi_ ( 0 )



{
typedef sp_counted_impl_pda < P , D , A > impl_type ;
typedef typename A :: template rebind < impl_type > :: other A2 ;

A2 a2 ( a ) ;



try
{
pi_ = a2 . allocate ( 1 , static_cast < impl_type * > ( 0 ) ) ;
new ( static_cast < void * > ( pi_ ) ) impl_type ( p , a ) ;
}
catch ( ... )
{
D :: operator_fn ( p ) ;

if ( pi_ != 0 )
{
a2 . deallocate ( static_cast < impl_type * > ( pi_ ) , 1 ) ;
}

throw ;
}
#314
}
#322
template < class Y >
explicit shared_count ( std :: auto_ptr < Y > & r ) : pi_ ( new sp_counted_impl_p < Y > ( r . get ( ) ) )



{
#337
r . release ( ) ;
}
#369
~ shared_count ( )
{
if ( pi_ != 0 ) pi_ -> release ( ) ;



}

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



{
if ( pi_ != 0 ) pi_ -> add_ref_copy ( ) ;
}
#397
explicit shared_count ( weak_count const & r ) ;
shared_count ( weak_count const & r , sp_nothrow_tag ) ;

shared_count & operator = ( shared_count const & r )
{
sp_counted_base * tmp = r . pi_ ;

if ( tmp != pi_ )
{
if ( tmp != 0 ) tmp -> add_ref_copy ( ) ;
if ( pi_ != 0 ) pi_ -> release ( ) ;
pi_ = tmp ;
}

return * this ;
}

void swap ( shared_count & r )
{
sp_counted_base * tmp = r . pi_ ;
r . pi_ = pi_ ;
pi_ = tmp ;
}

long use_count ( ) const
{
return pi_ != 0 ? pi_ -> use_count ( ) : 0 ;
}

bool unique ( ) const
{
return use_count ( ) == 1 ;
}

bool empty ( ) const
{
return pi_ == 0 ;
}

friend inline bool operator == ( shared_count const & a , shared_count const & b )
{
return a . pi_ == b . pi_ ;
}

friend inline bool operator < ( shared_count const & a , shared_count const & b )
{
return std :: less < sp_counted_base * > ( ) ( a . pi_ , b . pi_ ) ;
}

void * get_deleter ( sp_typeinfo const & ti ) const
{
return pi_ ? pi_ -> get_deleter ( ti ) : 0 ;
}

void * get_untyped_deleter ( ) const
{
return pi_ ? pi_ -> get_untyped_deleter ( ) : 0 ;
}
} ;


class weak_count
{
private :

sp_counted_base * pi_ ;





friend class shared_count ;

public :

weak_count ( ) : pi_ ( 0 )



{
}

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



{
if ( pi_ != 0 ) pi_ -> weak_add_ref ( ) ;
}

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



{
if ( pi_ != 0 ) pi_ -> weak_add_ref ( ) ;
}
#509
~ weak_count ( )
{
if ( pi_ != 0 ) pi_ -> weak_release ( ) ;



}

weak_count & operator = ( shared_count const & r )
{
sp_counted_base * tmp = r . pi_ ;

if ( tmp != pi_ )
{
if ( tmp != 0 ) tmp -> weak_add_ref ( ) ;
if ( pi_ != 0 ) pi_ -> weak_release ( ) ;
pi_ = tmp ;
}

return * this ;
}

weak_count & operator = ( weak_count const & r )
{
sp_counted_base * tmp = r . pi_ ;

if ( tmp != pi_ )
{
if ( tmp != 0 ) tmp -> weak_add_ref ( ) ;
if ( pi_ != 0 ) pi_ -> weak_release ( ) ;
pi_ = tmp ;
}

return * this ;
}

void swap ( weak_count & r )
{
sp_counted_base * tmp = r . pi_ ;
r . pi_ = pi_ ;
pi_ = tmp ;
}

long use_count ( ) const
{
return pi_ != 0 ? pi_ -> use_count ( ) : 0 ;
}

bool empty ( ) const
{
return pi_ == 0 ;
}

friend inline bool operator == ( weak_count const & a , weak_count const & b )
{
return a . pi_ == b . pi_ ;
}

friend inline bool operator < ( weak_count const & a , weak_count const & b )
{
return std :: less < sp_counted_base * > ( ) ( a . pi_ , b . pi_ ) ;
}
} ;

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



{
if ( pi_ == 0 || ! pi_ -> add_ref_lock ( ) )
{
boost :: throw_exception ( boost :: bad_weak_ptr ( ) ) ;
}
}

inline shared_count :: shared_count ( weak_count const & r , sp_nothrow_tag ) : pi_ ( r . pi_ )



{
if ( pi_ != 0 && ! pi_ -> add_ref_lock ( ) )
{
pi_ = 0 ;
}
}

}

}
#1 "./boost/smart_ptr/detail/sp_convertible.hpp"
#34
namespace boost
{

namespace detail
{

template < class Y , class T > struct sp_convertible
{
typedef char ( & yes ) [ 1 ] ;
typedef char ( & no ) [ 2 ] ;

static yes f ( T * ) ;
static no f ( ... ) ;

enum _vt { value = sizeof ( ( f ) ( static_cast < Y * > ( 0 ) ) ) == sizeof ( yes ) } ;
} ;

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

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

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

struct sp_empty
{
} ;

template < bool > struct sp_enable_if_convertible_impl ;

template < > struct sp_enable_if_convertible_impl < true >
{
typedef sp_empty type ;
} ;

template < > struct sp_enable_if_convertible_impl < false >
{
} ;

template < class Y , class T > struct sp_enable_if_convertible : public sp_enable_if_convertible_impl < sp_convertible <
#81
Y , T > :: value >
{
} ;

}

}
#1 "./boost/memory_order.hpp"
#21
namespace boost
{
#41
enum memory_order
{
memory_order_relaxed = 0 ,
memory_order_acquire = 1 ,
memory_order_release = 2 ,
memory_order_acq_rel = 3 ,
memory_order_seq_cst = 7 ,
memory_order_consume = 8
} ;

}
#55 "./boost/smart_ptr/shared_ptr.hpp"
namespace boost
{

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

namespace detail
{



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



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



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

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



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

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

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





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



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



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



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



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



template < class T , std :: size_t N > struct sp_array_access < T [ N ] >
{
typedef T & type ;
} ;
#192
template < class T > struct sp_extent
{
enum _vt { value = 0 } ;
} ;



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





template < class X , class Y , class T > inline void sp_enable_shared_from_this ( boost :: shared_ptr < X > const * ppx ,
#208
Y const * py , boost :: enable_shared_from_this < T > const * pe )
{
if ( pe != 0 )
{
pe -> _internal_accept_owner ( ppx , const_cast < Y * > ( py ) ) ;
}
}

template < class X , class Y > inline void sp_enable_shared_from_this ( boost :: shared_ptr < X > * ppx , Y const * py ,
#216
boost :: enable_shared_from_raw const * pe ) ;
#233
inline void sp_enable_shared_from_this ( ... )
{
}
#243
template < class T , class R > struct sp_enable_if_auto_ptr
{
} ;

template < class T , class R > struct sp_enable_if_auto_ptr < std :: auto_ptr < T > , R >
{
typedef R type ;
} ;





template < class Y , class T > inline void sp_assert_convertible ( )
{



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



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



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

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





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



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

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



}
#328
template < class T > class shared_ptr
{
private :


typedef shared_ptr < T > this_type ;

public :

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

shared_ptr ( ) : px ( 0 ) , pn ( )
{
}
#351
template < class Y >
explicit shared_ptr ( Y * p ) : px ( p ) , pn ( )
{
boost :: detail :: sp_pointer_construct ( this , p , pn ) ;
}
#363
template < class Y , class D > shared_ptr ( Y * p , D d ) : px ( p ) , pn ( p , d )
{
boost :: detail :: sp_deleter_construct ( this , p ) ;
}
#378
template < class Y , class D , class A > shared_ptr ( Y * p , D d , A a ) : px ( p ) , pn ( p , d , a )
{
boost :: detail :: sp_deleter_construct ( this , p ) ;
}
#403
template < class Y >
explicit shared_ptr ( weak_ptr < Y > const & r ) : pn ( r . pn )
{
boost :: detail :: sp_assert_convertible < Y , T > ( ) ;


px = r . px ;
}

template < class Y >
shared_ptr ( weak_ptr < Y > const & r , boost :: detail :: sp_nothrow_tag )
: px ( 0 ) , pn ( r . pn , boost :: detail :: sp_nothrow_tag ( ) )
{
if ( ! pn . empty ( ) )
{
px = r . px ;
}
}

template < class Y >


shared_ptr ( shared_ptr < Y > const & r , typename boost :: detail :: sp_enable_if_convertible < Y , T > :: type = boost
#425
:: detail :: sp_empty ( ) )
#432
: px ( r . px ) , pn ( r . pn )
{
boost :: detail :: sp_assert_convertible < Y , T > ( ) ;
}


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



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

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

boost :: detail :: sp_deleter_construct ( this , tmp ) ;
}
#471
template < class Ap >
explicit shared_ptr ( Ap r , typename boost :: detail :: sp_enable_if_auto_ptr < Ap , int > :: type = 0 ) : px ( r . get
#472
( ) ) , pn ( )
{
typedef typename Ap :: element_type Y ;

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

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

boost :: detail :: sp_deleter_construct ( this , tmp ) ;
}
#505
shared_ptr & operator = ( shared_ptr const & r )
{
this_type ( r ) . swap ( * this ) ;
return * this ;
}



template < class Y >
shared_ptr & operator = ( shared_ptr < Y > const & r )
{
this_type ( r ) . swap ( * this ) ;
return * this ;
}





template < class Y >
shared_ptr & operator = ( std :: auto_ptr < Y > & r )
{
this_type ( r ) . swap ( * this ) ;
return * this ;
}
#542
template < class Ap >
typename boost :: detail :: sp_enable_if_auto_ptr < Ap , shared_ptr & > :: type operator = ( Ap r )
{
this_type ( r ) . swap ( * this ) ;
return * this ;
}
#617
void reset ( )
{
this_type ( ) . swap ( * this ) ;
}

template < class Y > void reset ( Y * p )
{
( ( void ) 0 ) ;
this_type ( p ) . swap ( * this ) ;
}

template < class Y , class D > void reset ( Y * p , D d )
{
this_type ( p , d ) . swap ( * this ) ;
}

template < class Y , class D , class A > void reset ( Y * p , D d , A a )
{
this_type ( p , d , a ) . swap ( * this ) ;
}

template < class Y > void reset ( shared_ptr < Y > const & r , element_type * p )
{
this_type ( r , p ) . swap ( * this ) ;
}


typename boost :: detail :: sp_dereference < T > :: type operator * ( ) const
{
( ( void ) 0 ) ;
return * px ;
}


typename boost :: detail :: sp_member_access < T > :: type operator -> ( ) const
{
( ( void ) 0 ) ;
return px ;
}


typename boost :: detail :: sp_array_access < T > :: type operator [ ] ( std :: ptrdiff_t i ) const
{
( ( void ) 0 ) ;
( ( void ) 0 ) ;

return px [ i ] ;
}

element_type * get ( ) const
{
return px ;
}
#1 "./boost/smart_ptr/detail/operator_bool.hpp"
#50
typedef element_type * this_type :: * unspecified_bool_type ;

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




bool operator ! ( ) const
{
return px == 0 ;
}
#674 "./boost/smart_ptr/shared_ptr.hpp"
bool unique ( ) const
{
return pn . unique ( ) ;
}

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

void swap ( shared_ptr & other )
{
std :: swap ( px , other . px ) ;
pn . swap ( other . pn ) ;
}

template < class Y > bool owner_before ( shared_ptr < Y > const & rhs ) const
{
return pn < rhs . pn ;
}

template < class Y > bool owner_before ( weak_ptr < Y > const & rhs ) const
{
return pn < rhs . pn ;
}

void * _internal_get_deleter ( boost :: detail :: sp_typeinfo const & ti ) const
{
return pn . get_deleter ( ti ) ;
}

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

bool _internal_equiv ( shared_ptr const & r ) const
{
return px == r . px && pn == r . pn ;
}
#720
private :

template < class Y > friend class shared_ptr ;
template < class Y > friend class weak_ptr ;




element_type * px ;
boost :: detail :: shared_count pn ;

} ;

template < class T , class U > inline bool operator == ( shared_ptr < T > const & a , shared_ptr < U > const & b )
{
return a . get ( ) == b . get ( ) ;
}

template < class T , class U > inline bool operator != ( shared_ptr < T > const & a , shared_ptr < U > const & b )
{
return a . get ( ) != b . get ( ) ;
}
#778
template < class T , class U > inline bool operator < ( shared_ptr < T > const & a , shared_ptr < U > const & b )
{
return a . owner_before ( b ) ;
}

template < class T > inline void swap ( shared_ptr < T > & a , shared_ptr < T > & b )
{
a . swap ( b ) ;
}

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

typedef typename shared_ptr < T > :: element_type E ;

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

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

typedef typename shared_ptr < T > :: element_type E ;

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

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

typedef typename shared_ptr < T > :: element_type E ;

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

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

typedef typename shared_ptr < T > :: element_type E ;

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



template < class T > inline typename shared_ptr < T > :: element_type * get_pointer ( shared_ptr < T > const & p )
{
return p . get ( ) ;
}
#857
template < class E , class T , class Y > std :: basic_ostream < E , T > & operator << ( std :: basic_ostream < E , T > &
#857
os , shared_ptr < Y > const & p )

{
os << p . get ( ) ;
return os ;
}
#872
namespace detail
{
#890
template < class D , class T > D * basic_get_deleter ( shared_ptr < T > const & p )
{
return static_cast < D * > ( p . _internal_get_deleter ( typeid ( D ) ) ) ;
}



class esft2_deleter_wrapper
{
private :

shared_ptr < void > deleter_ ;

public :

esft2_deleter_wrapper ( )
{
}

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

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

template < class T > void operator ( ) ( T * )
{
( ( void ) 0 ) ;
deleter_ . reset ( ) ;
}
} ;

}

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

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


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

return del ;
}





template < class T > inline bool atomic_is_lock_free ( shared_ptr < T > const * )
{
return false ;
}

template < class T > shared_ptr < T > atomic_load ( shared_ptr < T > const * p )
{
boost :: detail :: spinlock_pool < 2 > :: scoped_lock lock ( p ) ;
return * p ;
}

template < class T > inline shared_ptr < T > atomic_load_explicit ( shared_ptr < T > const * p , memory_order )
{
return atomic_load ( p ) ;
}

template < class T > void atomic_store ( shared_ptr < T > * p , shared_ptr < T > r )
{
boost :: detail :: spinlock_pool < 2 > :: scoped_lock lock ( p ) ;
p -> swap ( r ) ;
}

template < class T > inline void atomic_store_explicit ( shared_ptr < T > * p , shared_ptr < T > r , memory_order )
{
atomic_store ( p , r ) ;
}

template < class T > shared_ptr < T > atomic_exchange ( shared_ptr < T > * p , shared_ptr < T > r )
{
boost :: detail :: spinlock & sp = boost :: detail :: spinlock_pool < 2 > :: spinlock_for ( p ) ;

sp . lock ( ) ;
p -> swap ( r ) ;
sp . unlock ( ) ;

return r ;
}

template < class T > shared_ptr < T > atomic_exchange_explicit ( shared_ptr < T > * p , shared_ptr < T > r , memory_order
#985
)
{
return atomic_exchange ( p , r ) ;
}

template < class T > bool atomic_compare_exchange ( shared_ptr < T > * p , shared_ptr < T > * v , shared_ptr < T > w )
{
boost :: detail :: spinlock & sp = boost :: detail :: spinlock_pool < 2 > :: spinlock_for ( p ) ;

sp . lock ( ) ;

if ( p -> _internal_equiv ( * v ) )
{
p -> swap ( w ) ;

sp . unlock ( ) ;

return true ;
}
else
{
shared_ptr < T > tmp ( * p ) ;

sp . unlock ( ) ;

tmp . swap ( * v ) ;
return false ;
}
}

template < class T > inline bool atomic_compare_exchange_explicit ( shared_ptr < T > * p , shared_ptr < T > * v , shared_ptr
#1015
< T > w , memory_order , memory_order )
{
return atomic_compare_exchange ( p , v , w ) ;
}





template < class T > struct hash ;

template < class T > std :: size_t hash_value ( boost :: shared_ptr < T > const & p )
{
return boost :: hash < T * > ( ) ( p . get ( ) ) ;
}

}
#1 "./boost/mpl/bool_fwd.hpp"
#1 "./boost/mpl/aux_/adl_barrier.hpp"
#1 "./boost/mpl/aux_/config/adl.hpp"
#1 "./boost/mpl/aux_/config/msvc.hpp"
#1 "./boost/mpl/aux_/config/intel.hpp"
#1 "./boost/mpl/aux_/config/gcc.hpp"
#1 "./boost/mpl/aux_/config/workaround.hpp"
#33 "./boost/mpl/aux_/adl_barrier.hpp"
namespace mpl_ { namespace aux { } }
namespace boost { namespace mpl { using namespace mpl_ ;
namespace aux { using namespace mpl_ :: aux ; }
} }
#19 "./boost/mpl/bool_fwd.hpp"
namespace mpl_ {

template < bool C_ > struct bool_ ;


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

}

namespace boost { namespace mpl { using :: mpl_ :: bool_ ; } }
namespace boost { namespace mpl { using :: mpl_ :: true_ ; } }
namespace boost { namespace mpl { using :: mpl_ :: false_ ; } }
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/locale"
#36
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets_nonio.h"
#37
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/ctime"
#39
#pragma GCC system_header
#58
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 ;
}
#41 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets_nonio.h"
namespace std
{
#52
class time_base
{
public :
enum dateorder { no_order , dmy , mdy , ymd , ydm } ;
} ;

template < typename _CharT >
struct __timepunct_cache : public locale :: facet
{

static const _CharT * _S_timezones [ 14 ] ;

const _CharT * _M_date_format ;
const _CharT * _M_date_era_format ;
const _CharT * _M_time_format ;
const _CharT * _M_time_era_format ;
const _CharT * _M_date_time_format ;
const _CharT * _M_date_time_era_format ;
const _CharT * _M_am ;
const _CharT * _M_pm ;
const _CharT * _M_am_pm_format ;


const _CharT * _M_day1 ;
const _CharT * _M_day2 ;
const _CharT * _M_day3 ;
const _CharT * _M_day4 ;
const _CharT * _M_day5 ;
const _CharT * _M_day6 ;
const _CharT * _M_day7 ;


const _CharT * _M_aday1 ;
const _CharT * _M_aday2 ;
const _CharT * _M_aday3 ;
const _CharT * _M_aday4 ;
const _CharT * _M_aday5 ;
const _CharT * _M_aday6 ;
const _CharT * _M_aday7 ;


const _CharT * _M_month01 ;
const _CharT * _M_month02 ;
const _CharT * _M_month03 ;
const _CharT * _M_month04 ;
const _CharT * _M_month05 ;
const _CharT * _M_month06 ;
const _CharT * _M_month07 ;
const _CharT * _M_month08 ;
const _CharT * _M_month09 ;
const _CharT * _M_month10 ;
const _CharT * _M_month11 ;
const _CharT * _M_month12 ;


const _CharT * _M_amonth01 ;
const _CharT * _M_amonth02 ;
const _CharT * _M_amonth03 ;
const _CharT * _M_amonth04 ;
const _CharT * _M_amonth05 ;
const _CharT * _M_amonth06 ;
const _CharT * _M_amonth07 ;
const _CharT * _M_amonth08 ;
const _CharT * _M_amonth09 ;
const _CharT * _M_amonth10 ;
const _CharT * _M_amonth11 ;
const _CharT * _M_amonth12 ;

bool _M_allocated ;

__timepunct_cache ( size_t __refs = 0 ) : facet ( __refs ) ,
_M_date_format ( 0 ) , _M_date_era_format ( 0 ) , _M_time_format ( 0 ) ,
_M_time_era_format ( 0 ) , _M_date_time_format ( 0 ) ,
_M_date_time_era_format ( 0 ) , _M_am ( 0 ) , _M_pm ( 0 ) ,
_M_am_pm_format ( 0 ) , _M_day1 ( 0 ) , _M_day2 ( 0 ) , _M_day3 ( 0 ) ,
_M_day4 ( 0 ) , _M_day5 ( 0 ) , _M_day6 ( 0 ) , _M_day7 ( 0 ) ,
_M_aday1 ( 0 ) , _M_aday2 ( 0 ) , _M_aday3 ( 0 ) , _M_aday4 ( 0 ) ,
_M_aday5 ( 0 ) , _M_aday6 ( 0 ) , _M_aday7 ( 0 ) , _M_month01 ( 0 ) ,
_M_month02 ( 0 ) , _M_month03 ( 0 ) , _M_month04 ( 0 ) , _M_month05 ( 0 ) ,
_M_month06 ( 0 ) , _M_month07 ( 0 ) , _M_month08 ( 0 ) , _M_month09 ( 0 ) ,
_M_month10 ( 0 ) , _M_month11 ( 0 ) , _M_month12 ( 0 ) , _M_amonth01 ( 0 ) ,
_M_amonth02 ( 0 ) , _M_amonth03 ( 0 ) , _M_amonth04 ( 0 ) ,
_M_amonth05 ( 0 ) , _M_amonth06 ( 0 ) , _M_amonth07 ( 0 ) ,
_M_amonth08 ( 0 ) , _M_amonth09 ( 0 ) , _M_amonth10 ( 0 ) ,
_M_amonth11 ( 0 ) , _M_amonth12 ( 0 ) , _M_allocated ( false )
{ }

~ __timepunct_cache ( ) ;

void
_M_cache ( const locale & __loc ) ;

private :
__timepunct_cache &
operator = ( const __timepunct_cache & ) ;

explicit
__timepunct_cache ( const __timepunct_cache & ) ;
} ;

template < typename _CharT >
__timepunct_cache < _CharT > :: ~ __timepunct_cache ( )
{
if ( _M_allocated )
{

}
}


template < >
const char *
__timepunct_cache < char > :: _S_timezones [ 14 ] ;


template < >
const wchar_t *
__timepunct_cache < wchar_t > :: _S_timezones [ 14 ] ;



template < typename _CharT >
const _CharT * __timepunct_cache < _CharT > :: _S_timezones [ 14 ] ;

template < typename _CharT >
class __timepunct : public locale :: facet
{
public :

typedef _CharT __char_type ;
typedef basic_string < _CharT > __string_type ;
typedef __timepunct_cache < _CharT > __cache_type ;

protected :
__cache_type * _M_data ;
__c_locale _M_c_locale_timepunct ;
const char * _M_name_timepunct ;

public :

static locale :: id id ;

explicit
__timepunct ( size_t __refs = 0 ) ;

explicit
__timepunct ( __cache_type * __cache , size_t __refs = 0 ) ;
#210
explicit
__timepunct ( __c_locale __cloc , const char * __s , size_t __refs = 0 ) ;



void
_M_put ( _CharT * __s , size_t __maxlen , const _CharT * __format ,
const tm * __tm ) const throw ( ) ;

void
_M_date_formats ( const _CharT * * __date ) const
{

__date [ 0 ] = _M_data -> _M_date_format ;
__date [ 1 ] = _M_data -> _M_date_era_format ;
}

void
_M_time_formats ( const _CharT * * __time ) const
{

__time [ 0 ] = _M_data -> _M_time_format ;
__time [ 1 ] = _M_data -> _M_time_era_format ;
}

void
_M_date_time_formats ( const _CharT * * __dt ) const
{

__dt [ 0 ] = _M_data -> _M_date_time_format ;
__dt [ 1 ] = _M_data -> _M_date_time_era_format ;
}

void
_M_am_pm_format ( const _CharT * __ampm ) const
{ __ampm = _M_data -> _M_am_pm_format ; }

void
_M_am_pm ( const _CharT * * __ampm ) const
{
__ampm [ 0 ] = _M_data -> _M_am ;
__ampm [ 1 ] = _M_data -> _M_pm ;
}

void
_M_days ( const _CharT * * __days ) const
{
__days [ 0 ] = _M_data -> _M_day1 ;
__days [ 1 ] = _M_data -> _M_day2 ;
__days [ 2 ] = _M_data -> _M_day3 ;
__days [ 3 ] = _M_data -> _M_day4 ;
__days [ 4 ] = _M_data -> _M_day5 ;
__days [ 5 ] = _M_data -> _M_day6 ;
__days [ 6 ] = _M_data -> _M_day7 ;
}

void
_M_days_abbreviated ( const _CharT * * __days ) const
{
__days [ 0 ] = _M_data -> _M_aday1 ;
__days [ 1 ] = _M_data -> _M_aday2 ;
__days [ 2 ] = _M_data -> _M_aday3 ;
__days [ 3 ] = _M_data -> _M_aday4 ;
__days [ 4 ] = _M_data -> _M_aday5 ;
__days [ 5 ] = _M_data -> _M_aday6 ;
__days [ 6 ] = _M_data -> _M_aday7 ;
}

void
_M_months ( const _CharT * * __months ) const
{
__months [ 0 ] = _M_data -> _M_month01 ;
__months [ 1 ] = _M_data -> _M_month02 ;
__months [ 2 ] = _M_data -> _M_month03 ;
__months [ 3 ] = _M_data -> _M_month04 ;
__months [ 4 ] = _M_data -> _M_month05 ;
__months [ 5 ] = _M_data -> _M_month06 ;
__months [ 6 ] = _M_data -> _M_month07 ;
__months [ 7 ] = _M_data -> _M_month08 ;
__months [ 8 ] = _M_data -> _M_month09 ;
__months [ 9 ] = _M_data -> _M_month10 ;
__months [ 10 ] = _M_data -> _M_month11 ;
__months [ 11 ] = _M_data -> _M_month12 ;
}

void
_M_months_abbreviated ( const _CharT * * __months ) const
{
__months [ 0 ] = _M_data -> _M_amonth01 ;
__months [ 1 ] = _M_data -> _M_amonth02 ;
__months [ 2 ] = _M_data -> _M_amonth03 ;
__months [ 3 ] = _M_data -> _M_amonth04 ;
__months [ 4 ] = _M_data -> _M_amonth05 ;
__months [ 5 ] = _M_data -> _M_amonth06 ;
__months [ 6 ] = _M_data -> _M_amonth07 ;
__months [ 7 ] = _M_data -> _M_amonth08 ;
__months [ 8 ] = _M_data -> _M_amonth09 ;
__months [ 9 ] = _M_data -> _M_amonth10 ;
__months [ 10 ] = _M_data -> _M_amonth11 ;
__months [ 11 ] = _M_data -> _M_amonth12 ;
}

protected :
virtual
~ __timepunct ( ) ;


void
_M_initialize_timepunct ( __c_locale __cloc = 0 ) ;
} ;

template < typename _CharT >
locale :: id __timepunct < _CharT > :: id ;


template < >
void
__timepunct < char > :: _M_initialize_timepunct ( __c_locale __cloc ) ;

template < >
void
__timepunct < char > :: _M_put ( char * , size_t , const char * , const tm * ) const throw ( ) ;


template < >
void
__timepunct < wchar_t > :: _M_initialize_timepunct ( __c_locale __cloc ) ;

template < >
void
__timepunct < wchar_t > :: _M_put ( wchar_t * , size_t , const wchar_t * ,
const tm * ) const throw ( ) ;



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/time_members.h"
#37
namespace std
{


template < typename _CharT >
__timepunct < _CharT > :: __timepunct ( size_t __refs )
: facet ( __refs ) , _M_data ( 0 )
{
_M_name_timepunct = _S_get_c_name ( ) ;
_M_initialize_timepunct ( ) ;
}

template < typename _CharT >
__timepunct < _CharT > :: __timepunct ( __cache_type * __cache , size_t __refs )
: facet ( __refs ) , _M_data ( __cache )
{
_M_name_timepunct = _S_get_c_name ( ) ;
_M_initialize_timepunct ( ) ;
}

template < typename _CharT >
__timepunct < _CharT > :: __timepunct ( __c_locale __cloc , const char * __s ,
size_t __refs )
: facet ( __refs ) , _M_data ( 0 )
{
if ( __builtin_strcmp ( __s , _S_get_c_name ( ) ) != 0 )
{
const size_t __len = __builtin_strlen ( __s ) + 1 ;
char * __tmp = new char [ __len ] ;
__builtin_memcpy ( __tmp , __s , __len ) ;
_M_name_timepunct = __tmp ;
}
else
_M_name_timepunct = _S_get_c_name ( ) ;

try
{ _M_initialize_timepunct ( __cloc ) ; }
catch ( ... )
{
if ( _M_name_timepunct != _S_get_c_name ( ) )
delete [ ] _M_name_timepunct ;
throw ;
}
}

template < typename _CharT >
__timepunct < _CharT > :: ~ __timepunct ( )
{
if ( _M_name_timepunct != _S_get_c_name ( ) )
delete [ ] _M_name_timepunct ;
delete _M_data ;
_S_destroy_c_locale ( _M_c_locale_timepunct ) ;
}


}
#350 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets_nonio.h"
namespace std
{
#367
template < typename _CharT , typename _InIter >
class time_get : public locale :: facet , public time_base
{
public :



typedef _CharT char_type ;
typedef _InIter iter_type ;

typedef basic_string < _CharT > __string_type ;


static locale :: id id ;
#389
explicit
time_get ( size_t __refs = 0 )
: facet ( __refs ) { }
#406
dateorder
date_order ( ) const
{ return this -> do_date_order ( ) ; }
#430
iter_type
get_time ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{ return this -> do_get_time ( __beg , __end , __io , __err , __tm ) ; }
#455
iter_type
get_date ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{ return this -> do_get_date ( __beg , __end , __io , __err , __tm ) ; }
#483
iter_type
get_weekday ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{ return this -> do_get_weekday ( __beg , __end , __io , __err , __tm ) ; }
#512
iter_type
get_monthname ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{ return this -> do_get_monthname ( __beg , __end , __io , __err , __tm ) ; }
#538
iter_type
get_year ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{ return this -> do_get_year ( __beg , __end , __io , __err , __tm ) ; }

protected :

virtual
~ time_get ( ) { }
#558
virtual dateorder
do_date_order ( ) const ;
#576
virtual iter_type
do_get_time ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const ;
#595
virtual iter_type
do_get_date ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const ;
#614
virtual iter_type
do_get_weekday ( iter_type __beg , iter_type __end , ios_base & ,
ios_base :: iostate & __err , tm * __tm ) const ;
#633
virtual iter_type
do_get_monthname ( iter_type __beg , iter_type __end , ios_base & ,
ios_base :: iostate & __err , tm * __tm ) const ;
#652
virtual iter_type
do_get_year ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const ;


iter_type
_M_extract_num ( iter_type __beg , iter_type __end , int & __member ,
int __min , int __max , size_t __len ,
ios_base & __io , ios_base :: iostate & __err ) const ;


iter_type
_M_extract_name ( iter_type __beg , iter_type __end , int & __member ,
const _CharT * * __names , size_t __indexlen ,
ios_base & __io , ios_base :: iostate & __err ) const ;


iter_type
_M_extract_wday_or_month ( iter_type __beg , iter_type __end , int & __member ,
const _CharT * * __names , size_t __indexlen ,
ios_base & __io , ios_base :: iostate & __err ) const ;


iter_type
_M_extract_via_format ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ,
const _CharT * __format ) const ;
} ;

template < typename _CharT , typename _InIter >
locale :: id time_get < _CharT , _InIter > :: id ;


template < typename _CharT , typename _InIter >
class time_get_byname : public time_get < _CharT , _InIter >
{
public :

typedef _CharT char_type ;
typedef _InIter iter_type ;

explicit
time_get_byname ( const char * , size_t __refs = 0 )
: time_get < _CharT , _InIter > ( __refs ) { }

protected :
virtual
~ time_get_byname ( ) { }
} ;
#714
template < typename _CharT , typename _OutIter >
class time_put : public locale :: facet
{
public :



typedef _CharT char_type ;
typedef _OutIter iter_type ;



static locale :: id id ;
#735
explicit
time_put ( size_t __refs = 0 )
: facet ( __refs ) { }
#754
iter_type
put ( iter_type __s , ios_base & __io , char_type __fill , const tm * __tm ,
const _CharT * __beg , const _CharT * __end ) const ;
#774
iter_type
put ( iter_type __s , ios_base & __io , char_type __fill ,
const tm * __tm , char __format , char __mod = 0 ) const
{ return this -> do_put ( __s , __io , __fill , __tm , __format , __mod ) ; }

protected :

virtual
~ time_put ( )
{ }
#801
virtual iter_type
do_put ( iter_type __s , ios_base & __io , char_type __fill , const tm * __tm ,
char __format , char __mod ) const ;
} ;

template < typename _CharT , typename _OutIter >
locale :: id time_put < _CharT , _OutIter > :: id ;


template < typename _CharT , typename _OutIter >
class time_put_byname : public time_put < _CharT , _OutIter >
{
public :

typedef _CharT char_type ;
typedef _OutIter iter_type ;

explicit
time_put_byname ( const char * , size_t __refs = 0 )
: time_put < _CharT , _OutIter > ( __refs )
{ } ;

protected :
virtual
~ time_put_byname ( ) { }
} ;
#840
class money_base
{
public :
enum part { none , space , symbol , sign , value } ;
struct pattern { char field [ 4 ] ; } ;

static const pattern _S_default_pattern ;

enum
{
_S_minus ,
_S_zero ,
_S_end = 11
} ;



static const char * _S_atoms ;



__attribute__ ( ( __const__ ) ) static pattern
_S_construct_pattern ( char __precedes , char __space , char __posn ) throw ( ) ;
} ;

template < typename _CharT , bool _Intl >
struct __moneypunct_cache : public locale :: facet
{
const char * _M_grouping ;
size_t _M_grouping_size ;
bool _M_use_grouping ;
_CharT _M_decimal_point ;
_CharT _M_thousands_sep ;
const _CharT * _M_curr_symbol ;
size_t _M_curr_symbol_size ;
const _CharT * _M_positive_sign ;
size_t _M_positive_sign_size ;
const _CharT * _M_negative_sign ;
size_t _M_negative_sign_size ;
int _M_frac_digits ;
money_base :: pattern _M_pos_format ;
money_base :: pattern _M_neg_format ;




_CharT _M_atoms [ money_base :: _S_end ] ;

bool _M_allocated ;

__moneypunct_cache ( size_t __refs = 0 ) : facet ( __refs ) ,
_M_grouping ( 0 ) , _M_grouping_size ( 0 ) , _M_use_grouping ( false ) ,
_M_decimal_point ( _CharT ( ) ) , _M_thousands_sep ( _CharT ( ) ) ,
_M_curr_symbol ( 0 ) , _M_curr_symbol_size ( 0 ) ,
_M_positive_sign ( 0 ) , _M_positive_sign_size ( 0 ) ,
_M_negative_sign ( 0 ) , _M_negative_sign_size ( 0 ) ,
_M_frac_digits ( 0 ) ,
_M_pos_format ( money_base :: pattern ( ) ) ,
_M_neg_format ( money_base :: pattern ( ) ) , _M_allocated ( false )
{ }

~ __moneypunct_cache ( ) ;

void
_M_cache ( const locale & __loc ) ;

private :
__moneypunct_cache &
operator = ( const __moneypunct_cache & ) ;

explicit
__moneypunct_cache ( const __moneypunct_cache & ) ;
} ;

template < typename _CharT , bool _Intl >
__moneypunct_cache < _CharT , _Intl > :: ~ __moneypunct_cache ( )
{
if ( _M_allocated )
{
delete [ ] _M_grouping ;
delete [ ] _M_curr_symbol ;
delete [ ] _M_positive_sign ;
delete [ ] _M_negative_sign ;
}
}
#933
template < typename _CharT , bool _Intl >
class moneypunct : public locale :: facet , public money_base
{
public :



typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;

typedef __moneypunct_cache < _CharT , _Intl > __cache_type ;

private :
__cache_type * _M_data ;

public :


static const bool intl = _Intl ;

static locale :: id id ;
#962
explicit
moneypunct ( size_t __refs = 0 )
: facet ( __refs ) , _M_data ( 0 )
{ _M_initialize_moneypunct ( ) ; }
#975
explicit
moneypunct ( __cache_type * __cache , size_t __refs = 0 )
: facet ( __refs ) , _M_data ( __cache )
{ _M_initialize_moneypunct ( ) ; }
#990
explicit
moneypunct ( __c_locale __cloc , const char * __s , size_t __refs = 0 )
: facet ( __refs ) , _M_data ( 0 )
{ _M_initialize_moneypunct ( __cloc , __s ) ; }
#1004
char_type
decimal_point ( ) const
{ return this -> do_decimal_point ( ) ; }
#1017
char_type
thousands_sep ( ) const
{ return this -> do_thousands_sep ( ) ; }
#1047
string
grouping ( ) const
{ return this -> do_grouping ( ) ; }
#1060
string_type
curr_symbol ( ) const
{ return this -> do_curr_symbol ( ) ; }
#1077
string_type
positive_sign ( ) const
{ return this -> do_positive_sign ( ) ; }
#1094
string_type
negative_sign ( ) const
{ return this -> do_negative_sign ( ) ; }
#1110
int
frac_digits ( ) const
{ return this -> do_frac_digits ( ) ; }
#1146
pattern
pos_format ( ) const
{ return this -> do_pos_format ( ) ; }

pattern
neg_format ( ) const
{ return this -> do_neg_format ( ) ; }


protected :

virtual
~ moneypunct ( ) ;
#1168
virtual char_type
do_decimal_point ( ) const
{ return _M_data -> _M_decimal_point ; }
#1180
virtual char_type
do_thousands_sep ( ) const
{ return _M_data -> _M_thousands_sep ; }
#1193
virtual string
do_grouping ( ) const
{ return _M_data -> _M_grouping ; }
#1206
virtual string_type
do_curr_symbol ( ) const
{ return _M_data -> _M_curr_symbol ; }
#1219
virtual string_type
do_positive_sign ( ) const
{ return _M_data -> _M_positive_sign ; }
#1232
virtual string_type
do_negative_sign ( ) const
{ return _M_data -> _M_negative_sign ; }
#1246
virtual int
do_frac_digits ( ) const
{ return _M_data -> _M_frac_digits ; }
#1260
virtual pattern
do_pos_format ( ) const
{ return _M_data -> _M_pos_format ; }
#1274
virtual pattern
do_neg_format ( ) const
{ return _M_data -> _M_neg_format ; }


void
_M_initialize_moneypunct ( __c_locale __cloc = 0 ,
const char * __name = 0 ) ;
} ;

template < typename _CharT , bool _Intl >
locale :: id moneypunct < _CharT , _Intl > :: id ;

template < typename _CharT , bool _Intl >
const bool moneypunct < _CharT , _Intl > :: intl ;

template < >
moneypunct < char , true > :: ~ moneypunct ( ) ;

template < >
moneypunct < char , false > :: ~ moneypunct ( ) ;

template < >
void
moneypunct < char , true > :: _M_initialize_moneypunct ( __c_locale , const char * ) ;

template < >
void
moneypunct < char , false > :: _M_initialize_moneypunct ( __c_locale , const char * ) ;


template < >
moneypunct < wchar_t , true > :: ~ moneypunct ( ) ;

template < >
moneypunct < wchar_t , false > :: ~ moneypunct ( ) ;

template < >
void
moneypunct < wchar_t , true > :: _M_initialize_moneypunct ( __c_locale ,
const char * ) ;

template < >
void
moneypunct < wchar_t , false > :: _M_initialize_moneypunct ( __c_locale ,
const char * ) ;



template < typename _CharT , bool _Intl >
class moneypunct_byname : public moneypunct < _CharT , _Intl >
{
public :
typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;

static const bool intl = _Intl ;

explicit
moneypunct_byname ( const char * __s , size_t __refs = 0 )
: moneypunct < _CharT , _Intl > ( __refs )
{
if ( __builtin_strcmp ( __s , "C" ) != 0
&& __builtin_strcmp ( __s , "POSIX" ) != 0 )
{
__c_locale __tmp ;
this -> _S_create_c_locale ( __tmp , __s ) ;
this -> _M_initialize_moneypunct ( __tmp ) ;
this -> _S_destroy_c_locale ( __tmp ) ;
}
}

protected :
virtual
~ moneypunct_byname ( ) { }
} ;

template < typename _CharT , bool _Intl >
const bool moneypunct_byname < _CharT , _Intl > :: intl ;
#1369
template < typename _CharT , typename _InIter >
class money_get : public locale :: facet
{
public :



typedef _CharT char_type ;
typedef _InIter iter_type ;
typedef basic_string < _CharT > string_type ;



static locale :: id id ;
#1391
explicit
money_get ( size_t __refs = 0 ) : facet ( __refs ) { }
#1421
iter_type
get ( iter_type __s , iter_type __end , bool __intl , ios_base & __io ,
ios_base :: iostate & __err , long double & __units ) const
{ return this -> do_get ( __s , __end , __intl , __io , __err , __units ) ; }
#1452
iter_type
get ( iter_type __s , iter_type __end , bool __intl , ios_base & __io ,
ios_base :: iostate & __err , string_type & __digits ) const
{ return this -> do_get ( __s , __end , __intl , __io , __err , __digits ) ; }

protected :

virtual
~ money_get ( ) { }
#1475
virtual iter_type
do_get ( iter_type __s , iter_type __end , bool __intl , ios_base & __io ,
ios_base :: iostate & __err , long double & __units ) const ;
#1487
virtual iter_type
do_get ( iter_type __s , iter_type __end , bool __intl , ios_base & __io ,
ios_base :: iostate & __err , string_type & __digits ) const ;
#1498
template < bool _Intl >
iter_type
_M_extract ( iter_type __s , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , string & __digits ) const ;
} ;

template < typename _CharT , typename _InIter >
locale :: id money_get < _CharT , _InIter > :: id ;
#1520
template < typename _CharT , typename _OutIter >
class money_put : public locale :: facet
{
public :


typedef _CharT char_type ;
typedef _OutIter iter_type ;
typedef basic_string < _CharT > string_type ;



static locale :: id id ;
#1541
explicit
money_put ( size_t __refs = 0 ) : facet ( __refs ) { }
#1561
iter_type
put ( iter_type __s , bool __intl , ios_base & __io ,
char_type __fill , long double __units ) const
{ return this -> do_put ( __s , __intl , __io , __fill , __units ) ; }
#1584
iter_type
put ( iter_type __s , bool __intl , ios_base & __io ,
char_type __fill , const string_type & __digits ) const
{ return this -> do_put ( __s , __intl , __io , __fill , __digits ) ; }

protected :

virtual
~ money_put ( ) { }
#1618
virtual iter_type
do_put ( iter_type __s , bool __intl , ios_base & __io , char_type __fill ,
long double __units ) const ;
#1642
virtual iter_type
do_put ( iter_type __s , bool __intl , ios_base & __io , char_type __fill ,
const string_type & __digits ) const ;
#1653
template < bool _Intl >
iter_type
_M_insert ( iter_type __s , ios_base & __io , char_type __fill ,
const string_type & __digits ) const ;
} ;

template < typename _CharT , typename _OutIter >
locale :: id money_put < _CharT , _OutIter > :: id ;
#1668
struct messages_base
{
typedef int catalog ;
} ;
#1694
template < typename _CharT >
class messages : public locale :: facet , public messages_base
{
public :



typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;


protected :


__c_locale _M_c_locale_messages ;
const char * _M_name_messages ;

public :

static locale :: id id ;
#1722
explicit
messages ( size_t __refs = 0 ) ;
#1736
explicit
messages ( __c_locale __cloc , const char * __s , size_t __refs = 0 ) ;
#1749
catalog
open ( const basic_string < char > & __s , const locale & __loc ) const
{ return this -> do_open ( __s , __loc ) ; }
#1767
catalog
open ( const basic_string < char > & , const locale & , const char * ) const ;
#1785
string_type
get ( catalog __c , int __set , int __msgid , const string_type & __s ) const
{ return this -> do_get ( __c , __set , __msgid , __s ) ; }
#1796
void
close ( catalog __c ) const
{ return this -> do_close ( __c ) ; }

protected :

virtual
~ messages ( ) ;
#1816
virtual catalog
do_open ( const basic_string < char > & , const locale & ) const ;
#1835
virtual string_type
do_get ( catalog , int , int , const string_type & __dfault ) const ;
#1843
virtual void
do_close ( catalog ) const ;


char *
_M_convert_to_char ( const string_type & __msg ) const
{

return reinterpret_cast < char * > ( const_cast < _CharT * > ( __msg . c_str ( ) ) ) ;
}


string_type
_M_convert_from_char ( char * ) const
{

return string_type ( ) ;
}
} ;

template < typename _CharT >
locale :: id messages < _CharT > :: id ;


template < >
string
messages < char > :: do_get ( catalog , int , int , const string & ) const ;


template < >
wstring
messages < wchar_t > :: do_get ( catalog , int , int , const wstring & ) const ;



template < typename _CharT >
class messages_byname : public messages < _CharT >
{
public :
typedef _CharT char_type ;
typedef basic_string < _CharT > string_type ;

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

protected :
virtual
~ messages_byname ( )
{ }
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/i386-sun-solaris2.10/amd64/bits/messages_members.h"
#36
namespace std
{



template < typename _CharT >
messages < _CharT > :: messages ( size_t __refs )
: facet ( __refs )
{ _M_c_locale_messages = _S_get_c_locale ( ) ; }

template < typename _CharT >
messages < _CharT > :: messages ( __c_locale , const char * , size_t __refs )
: facet ( __refs )
{ _M_c_locale_messages = _S_get_c_locale ( ) ; }

template < typename _CharT >
typename messages < _CharT > :: catalog
messages < _CharT > :: open ( const basic_string < char > & __s , const locale & __loc ,
const char * ) const
{ 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 > & , const locale & ) const
{ return 0 ; }

template < typename _CharT >
typename messages < _CharT > :: string_type
messages < _CharT > :: do_get ( catalog , int , int ,
const string_type & __dfault ) const
{ return __dfault ; }

template < typename _CharT >
void
messages < _CharT > :: do_close ( catalog ) const
{ }


template < typename _CharT >
messages_byname < _CharT > :: messages_byname ( const char * __s , size_t __refs )
: messages < _CharT > ( __refs )
{
if ( __builtin_strcmp ( __s , "C" ) != 0
&& __builtin_strcmp ( __s , "POSIX" ) != 0 )
{
this -> _S_destroy_c_locale ( this -> _M_c_locale_messages ) ;
this -> _S_create_c_locale ( this -> _M_c_locale_messages , __s ) ;
}
}


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/codecvt.h"
#39
#pragma GCC system_header

namespace std
{



class codecvt_base
{
public :
enum result
{
ok ,
partial ,
error ,
noconv
} ;
} ;
#67
template < typename _InternT , typename _ExternT , typename _StateT >
class __codecvt_abstract_base
: public locale :: facet , public codecvt_base
{
public :

typedef codecvt_base :: result result ;
typedef _InternT intern_type ;
typedef _ExternT extern_type ;
typedef _StateT state_type ;
#115
result
out ( state_type & __state , const intern_type * __from ,
const intern_type * __from_end , const intern_type * & __from_next ,
extern_type * __to , extern_type * __to_end ,
extern_type * & __to_next ) const
{
return this -> do_out ( __state , __from , __from_end , __from_next ,
__to , __to_end , __to_next ) ;
}
#154
result
unshift ( state_type & __state , extern_type * __to , extern_type * __to_end ,
extern_type * & __to_next ) const
{ return this -> do_unshift ( __state , __to , __to_end , __to_next ) ; }
#195
result
in ( state_type & __state , const extern_type * __from ,
const extern_type * __from_end , const extern_type * & __from_next ,
intern_type * __to , intern_type * __to_end ,
intern_type * & __to_next ) const
{
return this -> do_in ( __state , __from , __from_end , __from_next ,
__to , __to_end , __to_next ) ;
}

int
encoding ( ) const throw ( )
{ return this -> do_encoding ( ) ; }

bool
always_noconv ( ) const throw ( )
{ return this -> do_always_noconv ( ) ; }

int
length ( state_type & __state , const extern_type * __from ,
const extern_type * __end , size_t __max ) const
{ return this -> do_length ( __state , __from , __end , __max ) ; }

int
max_length ( ) const throw ( )
{ return this -> do_max_length ( ) ; }

protected :
explicit
__codecvt_abstract_base ( size_t __refs = 0 ) : locale :: facet ( __refs ) { }

virtual
~ __codecvt_abstract_base ( ) { }
#236
virtual result
do_out ( state_type & __state , const intern_type * __from ,
const intern_type * __from_end , const intern_type * & __from_next ,
extern_type * __to , extern_type * __to_end ,
extern_type * & __to_next ) const = 0 ;

virtual result
do_unshift ( state_type & __state , extern_type * __to ,
extern_type * __to_end , extern_type * & __to_next ) const = 0 ;

virtual result
do_in ( state_type & __state , const extern_type * __from ,
const extern_type * __from_end , const extern_type * & __from_next ,
intern_type * __to , intern_type * __to_end ,
intern_type * & __to_next ) const = 0 ;

virtual int
do_encoding ( ) const throw ( ) = 0 ;

virtual bool
do_always_noconv ( ) const throw ( ) = 0 ;

virtual int
do_length ( state_type & , const extern_type * __from ,
const extern_type * __end , size_t __max ) const = 0 ;

virtual int
do_max_length ( ) const throw ( ) = 0 ;
} ;
#275
template < typename _InternT , typename _ExternT , typename _StateT >
class codecvt
: public __codecvt_abstract_base < _InternT , _ExternT , _StateT >
{
public :

typedef codecvt_base :: result result ;
typedef _InternT intern_type ;
typedef _ExternT extern_type ;
typedef _StateT state_type ;

protected :
__c_locale _M_c_locale_codecvt ;

public :
static locale :: id id ;

explicit
codecvt ( size_t __refs = 0 )
: __codecvt_abstract_base < _InternT , _ExternT , _StateT > ( __refs ) ,
_M_c_locale_codecvt ( 0 )
{ }

explicit
codecvt ( __c_locale __cloc , size_t __refs = 0 ) ;

protected :
virtual
~ codecvt ( ) { }

virtual result
do_out ( state_type & __state , const intern_type * __from ,
const intern_type * __from_end , const intern_type * & __from_next ,
extern_type * __to , extern_type * __to_end ,
extern_type * & __to_next ) const ;

virtual result
do_unshift ( state_type & __state , extern_type * __to ,
extern_type * __to_end , extern_type * & __to_next ) const ;

virtual result
do_in ( state_type & __state , const extern_type * __from ,
const extern_type * __from_end , const extern_type * & __from_next ,
intern_type * __to , intern_type * __to_end ,
intern_type * & __to_next ) const ;

virtual int
do_encoding ( ) const throw ( ) ;

virtual bool
do_always_noconv ( ) const throw ( ) ;

virtual int
do_length ( state_type & , const extern_type * __from ,
const extern_type * __end , size_t __max ) const ;

virtual int
do_max_length ( ) const throw ( ) ;
} ;

template < typename _InternT , typename _ExternT , typename _StateT >
locale :: id codecvt < _InternT , _ExternT , _StateT > :: id ;


template < >
class codecvt < char , char , mbstate_t >
: public __codecvt_abstract_base < char , char , mbstate_t >
{
public :

typedef char intern_type ;
typedef char extern_type ;
typedef mbstate_t state_type ;

protected :
__c_locale _M_c_locale_codecvt ;

public :
static locale :: id id ;

explicit
codecvt ( size_t __refs = 0 ) ;

explicit
codecvt ( __c_locale __cloc , size_t __refs = 0 ) ;

protected :
virtual
~ codecvt ( ) ;

virtual result
do_out ( state_type & __state , const intern_type * __from ,
const intern_type * __from_end , const intern_type * & __from_next ,
extern_type * __to , extern_type * __to_end ,
extern_type * & __to_next ) const ;

virtual result
do_unshift ( state_type & __state , extern_type * __to ,
extern_type * __to_end , extern_type * & __to_next ) const ;

virtual result
do_in ( state_type & __state , const extern_type * __from ,
const extern_type * __from_end , const extern_type * & __from_next ,
intern_type * __to , intern_type * __to_end ,
intern_type * & __to_next ) const ;

virtual int
do_encoding ( ) const throw ( ) ;

virtual bool
do_always_noconv ( ) const throw ( ) ;

virtual int
do_length ( state_type & , const extern_type * __from ,
const extern_type * __end , size_t __max ) const ;

virtual int
do_max_length ( ) const throw ( ) ;
} ;



template < >
class codecvt < wchar_t , char , mbstate_t >
: public __codecvt_abstract_base < wchar_t , char , mbstate_t >
{
public :

typedef wchar_t intern_type ;
typedef char extern_type ;
typedef mbstate_t state_type ;

protected :
__c_locale _M_c_locale_codecvt ;

public :
static locale :: id id ;

explicit
codecvt ( size_t __refs = 0 ) ;

explicit
codecvt ( __c_locale __cloc , size_t __refs = 0 ) ;

protected :
virtual
~ codecvt ( ) ;

virtual result
do_out ( state_type & __state , const intern_type * __from ,
const intern_type * __from_end , const intern_type * & __from_next ,
extern_type * __to , extern_type * __to_end ,
extern_type * & __to_next ) const ;

virtual result
do_unshift ( state_type & __state ,
extern_type * __to , extern_type * __to_end ,
extern_type * & __to_next ) const ;

virtual result
do_in ( state_type & __state ,
const extern_type * __from , const extern_type * __from_end ,
const extern_type * & __from_next ,
intern_type * __to , intern_type * __to_end ,
intern_type * & __to_next ) const ;

virtual
int do_encoding ( ) const throw ( ) ;

virtual
bool do_always_noconv ( ) const throw ( ) ;

virtual
int do_length ( state_type & , const extern_type * __from ,
const extern_type * __end , size_t __max ) const ;

virtual int
do_max_length ( ) const throw ( ) ;
} ;



template < typename _InternT , typename _ExternT , typename _StateT >
class codecvt_byname : public codecvt < _InternT , _ExternT , _StateT >
{
public :
explicit
codecvt_byname ( const char * __s , size_t __refs = 0 )
: codecvt < _InternT , _ExternT , _StateT > ( __refs )
{
if ( __builtin_strcmp ( __s , "C" ) != 0
&& __builtin_strcmp ( __s , "POSIX" ) != 0 )
{
this -> _S_destroy_c_locale ( this -> _M_c_locale_codecvt ) ;
this -> _S_create_c_locale ( this -> _M_c_locale_codecvt , __s ) ;
}
}

protected :
virtual
~ codecvt_byname ( ) { }
} ;




extern template class codecvt_byname < char , char , mbstate_t > ;

extern template
const codecvt < char , char , mbstate_t > &
use_facet < codecvt < char , char , mbstate_t > > ( const locale & ) ;

extern template
bool
has_facet < codecvt < char , char , mbstate_t > > ( const locale & ) ;


extern template class codecvt_byname < wchar_t , char , mbstate_t > ;

extern template
const codecvt < wchar_t , char , mbstate_t > &
use_facet < codecvt < wchar_t , char , mbstate_t > > ( const locale & ) ;

extern template
bool
has_facet < codecvt < wchar_t , char , mbstate_t > > ( const locale & ) ;




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/locale_facets_nonio.tcc"
#33
#pragma GCC system_header

namespace std
{


template < typename _CharT , bool _Intl >
struct __use_cache < __moneypunct_cache < _CharT , _Intl > >
{
const __moneypunct_cache < _CharT , _Intl > *
operator ( ) ( const locale & __loc ) const
{
const size_t __i = moneypunct < _CharT , _Intl > :: id . _M_id ( ) ;
const locale :: facet * * __caches = __loc . _M_impl -> _M_caches ;
if ( ! __caches [ __i ] )
{
__moneypunct_cache < _CharT , _Intl > * __tmp = 0 ;
try
{
__tmp = new __moneypunct_cache < _CharT , _Intl > ;
__tmp -> _M_cache ( __loc ) ;
}
catch ( ... )
{
delete __tmp ;
throw ;
}
__loc . _M_impl -> _M_install_cache ( __tmp , __i ) ;
}
return static_cast <
const __moneypunct_cache < _CharT , _Intl > * > ( __caches [ __i ] ) ;
}
} ;

template < typename _CharT , bool _Intl >
void
__moneypunct_cache < _CharT , _Intl > :: _M_cache ( const locale & __loc )
{
_M_allocated = true ;

const moneypunct < _CharT , _Intl > & __mp =
use_facet < moneypunct < _CharT , _Intl > > ( __loc ) ;

_M_decimal_point = __mp . decimal_point ( ) ;
_M_thousands_sep = __mp . thousands_sep ( ) ;
_M_frac_digits = __mp . frac_digits ( ) ;

char * __grouping = 0 ;
_CharT * __curr_symbol = 0 ;
_CharT * __positive_sign = 0 ;
_CharT * __negative_sign = 0 ;
try
{
_M_grouping_size = __mp . grouping ( ) . size ( ) ;
__grouping = new char [ _M_grouping_size ] ;
__mp . grouping ( ) . copy ( __grouping , _M_grouping_size ) ;
_M_grouping = __grouping ;
_M_use_grouping = ( _M_grouping_size
&& static_cast < signed char > ( _M_grouping [ 0 ] ) > 0
&& ( _M_grouping [ 0 ]
!= __gnu_cxx :: __numeric_traits < char > :: __max ) ) ;

_M_curr_symbol_size = __mp . curr_symbol ( ) . size ( ) ;
__curr_symbol = new _CharT [ _M_curr_symbol_size ] ;
__mp . curr_symbol ( ) . copy ( __curr_symbol , _M_curr_symbol_size ) ;
_M_curr_symbol = __curr_symbol ;

_M_positive_sign_size = __mp . positive_sign ( ) . size ( ) ;
__positive_sign = new _CharT [ _M_positive_sign_size ] ;
__mp . positive_sign ( ) . copy ( __positive_sign , _M_positive_sign_size ) ;
_M_positive_sign = __positive_sign ;

_M_negative_sign_size = __mp . negative_sign ( ) . size ( ) ;
__negative_sign = new _CharT [ _M_negative_sign_size ] ;
__mp . negative_sign ( ) . copy ( __negative_sign , _M_negative_sign_size ) ;
_M_negative_sign = __negative_sign ;

_M_pos_format = __mp . pos_format ( ) ;
_M_neg_format = __mp . neg_format ( ) ;

const ctype < _CharT > & __ct = use_facet < ctype < _CharT > > ( __loc ) ;
__ct . widen ( money_base :: _S_atoms ,
money_base :: _S_atoms + money_base :: _S_end , _M_atoms ) ;
}
catch ( ... )
{
delete [ ] __grouping ;
delete [ ] __curr_symbol ;
delete [ ] __positive_sign ;
delete [ ] __negative_sign ;
throw ;
}
}



template < typename _CharT , typename _InIter >
template < bool _Intl >
_InIter
money_get < _CharT , _InIter > ::
_M_extract ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , string & __units ) const
{
typedef char_traits < _CharT > __traits_type ;
typedef typename string_type :: size_type size_type ;
typedef money_base :: part part ;
typedef __moneypunct_cache < _CharT , _Intl > __cache_type ;

const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;

__use_cache < __cache_type > __uc ;
const __cache_type * __lc = __uc ( __loc ) ;
const char_type * __lit = __lc -> _M_atoms ;


bool __negative = false ;

size_type __sign_size = 0 ;

const bool __mandatory_sign = ( __lc -> _M_positive_sign_size
&& __lc -> _M_negative_sign_size ) ;

string __grouping_tmp ;
if ( __lc -> _M_use_grouping )
__grouping_tmp . reserve ( 32 ) ;

int __last_pos = 0 ;

int __n = 0 ;

bool __testvalid = true ;

bool __testdecfound = false ;


string __res ;
__res . reserve ( 32 ) ;

const char_type * __lit_zero = __lit + money_base :: _S_zero ;
const money_base :: pattern __p = __lc -> _M_neg_format ;
for ( int __i = 0 ; __i < 4 && __testvalid ; ++ __i )
{
const part __which = static_cast < part > ( __p . field [ __i ] ) ;
switch ( __which )
{
case money_base :: symbol :




if ( __io . flags ( ) & ios_base :: showbase || __sign_size > 1
|| __i == 0
|| ( __i == 1 && ( __mandatory_sign
|| ( static_cast < part > ( __p . field [ 0 ] )
== money_base :: sign )
|| ( static_cast < part > ( __p . field [ 2 ] )
== money_base :: space ) ) )
|| ( __i == 2 && ( ( static_cast < part > ( __p . field [ 3 ] )
== money_base :: value )
|| ( __mandatory_sign
&& ( static_cast < part > ( __p . field [ 3 ] )
== money_base :: sign ) ) ) ) )
{
const size_type __len = __lc -> _M_curr_symbol_size ;
size_type __j = 0 ;
for ( ; __beg != __end && __j < __len
&& * __beg == __lc -> _M_curr_symbol [ __j ] ;
++ __beg , ++ __j ) ;
if ( __j != __len
&& ( __j || __io . flags ( ) & ios_base :: showbase ) )
__testvalid = false ;
}
break ;
case money_base :: sign :

if ( __lc -> _M_positive_sign_size && __beg != __end
&& * __beg == __lc -> _M_positive_sign [ 0 ] )
{
__sign_size = __lc -> _M_positive_sign_size ;
++ __beg ;
}
else if ( __lc -> _M_negative_sign_size && __beg != __end
&& * __beg == __lc -> _M_negative_sign [ 0 ] )
{
__negative = true ;
__sign_size = __lc -> _M_negative_sign_size ;
++ __beg ;
}
else if ( __lc -> _M_positive_sign_size
&& ! __lc -> _M_negative_sign_size )


__negative = true ;
else if ( __mandatory_sign )
__testvalid = false ;
break ;
case money_base :: value :


for ( ; __beg != __end ; ++ __beg )
{
const char_type __c = * __beg ;
const char_type * __q = __traits_type :: find ( __lit_zero ,
10 , __c ) ;
if ( __q != 0 )
{
__res += money_base :: _S_atoms [ __q - __lit ] ;
++ __n ;
}
else if ( __c == __lc -> _M_decimal_point
&& ! __testdecfound )
{
if ( __lc -> _M_frac_digits <= 0 )
break ;

__last_pos = __n ;
__n = 0 ;
__testdecfound = true ;
}
else if ( __lc -> _M_use_grouping
&& __c == __lc -> _M_thousands_sep
&& ! __testdecfound )
{
if ( __n )
{

__grouping_tmp += static_cast < char > ( __n ) ;
__n = 0 ;
}
else
{
__testvalid = false ;
break ;
}
}
else
break ;
}
if ( __res . empty ( ) )
__testvalid = false ;
break ;
case money_base :: space :

if ( __beg != __end && __ctype . is ( ctype_base :: space , * __beg ) )
++ __beg ;
else
__testvalid = false ;
case money_base :: none :

if ( __i != 3 )
for ( ; __beg != __end
&& __ctype . is ( ctype_base :: space , * __beg ) ; ++ __beg ) ;
break ;
}
}


if ( __sign_size > 1 && __testvalid )
{
const char_type * __sign = __negative ? __lc -> _M_negative_sign
: __lc -> _M_positive_sign ;
size_type __i = 1 ;
for ( ; __beg != __end && __i < __sign_size
&& * __beg == __sign [ __i ] ; ++ __beg , ++ __i ) ;

if ( __i != __sign_size )
__testvalid = false ;
}

if ( __testvalid )
{

if ( __res . size ( ) > 1 )
{
const size_type __first = __res . find_first_not_of ( '0' ) ;
const bool __only_zeros = __first == string :: npos ;
if ( __first )
__res . erase ( 0 , __only_zeros ? __res . size ( ) - 1 : __first ) ;
}


if ( __negative && __res [ 0 ] != '0' )
__res . insert ( __res . begin ( ) , '-' ) ;


if ( __grouping_tmp . size ( ) )
{

__grouping_tmp += static_cast < char > ( __testdecfound ? __last_pos
: __n ) ;
if ( ! std :: __verify_grouping ( __lc -> _M_grouping ,
__lc -> _M_grouping_size ,
__grouping_tmp ) )
__err |= ios_base :: failbit ;
}


if ( __testdecfound && __n != __lc -> _M_frac_digits )
__testvalid = false ;
}


if ( ! __testvalid )
__err |= ios_base :: failbit ;
else
__units . swap ( __res ) ;


if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}
#362
template < typename _CharT , typename _InIter >
_InIter
money_get < _CharT , _InIter > ::
do_get ( iter_type __beg , iter_type __end , bool __intl , ios_base & __io ,
ios_base :: iostate & __err , long double & __units ) const
{
string __str ;
__beg = __intl ? _M_extract < true > ( __beg , __end , __io , __err , __str )
: _M_extract < false > ( __beg , __end , __io , __err , __str ) ;
std :: __convert_to_v ( __str . c_str ( ) , __units , __err , _S_get_c_locale ( ) ) ;
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
money_get < _CharT , _InIter > ::
do_get ( iter_type __beg , iter_type __end , bool __intl , ios_base & __io ,
ios_base :: iostate & __err , string_type & __digits ) const
{
typedef typename string :: size_type size_type ;

const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;

string __str ;
__beg = __intl ? _M_extract < true > ( __beg , __end , __io , __err , __str )
: _M_extract < false > ( __beg , __end , __io , __err , __str ) ;
const size_type __len = __str . size ( ) ;
if ( __len )
{
__digits . resize ( __len ) ;
__ctype . widen ( __str . data ( ) , __str . data ( ) + __len , & __digits [ 0 ] ) ;
}
return __beg ;
}

template < typename _CharT , typename _OutIter >
template < bool _Intl >
_OutIter
money_put < _CharT , _OutIter > ::
_M_insert ( iter_type __s , ios_base & __io , char_type __fill ,
const string_type & __digits ) const
{
typedef typename string_type :: size_type size_type ;
typedef money_base :: part part ;
typedef __moneypunct_cache < _CharT , _Intl > __cache_type ;

const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;

__use_cache < __cache_type > __uc ;
const __cache_type * __lc = __uc ( __loc ) ;
const char_type * __lit = __lc -> _M_atoms ;



const char_type * __beg = __digits . data ( ) ;

money_base :: pattern __p ;
const char_type * __sign ;
size_type __sign_size ;
if ( ! ( * __beg == __lit [ money_base :: _S_minus ] ) )
{
__p = __lc -> _M_pos_format ;
__sign = __lc -> _M_positive_sign ;
__sign_size = __lc -> _M_positive_sign_size ;
}
else
{
__p = __lc -> _M_neg_format ;
__sign = __lc -> _M_negative_sign ;
__sign_size = __lc -> _M_negative_sign_size ;
if ( __digits . size ( ) )
++ __beg ;
}


size_type __len = __ctype . scan_not ( ctype_base :: digit , __beg ,
__beg + __digits . size ( ) ) - __beg ;
if ( __len )
{



string_type __value ;
__value . reserve ( 2 * __len ) ;



long __paddec = __len - __lc -> _M_frac_digits ;
if ( __paddec > 0 )
{
if ( __lc -> _M_frac_digits < 0 )
__paddec = __len ;
if ( __lc -> _M_grouping_size )
{
__value . assign ( 2 * __paddec , char_type ( ) ) ;
_CharT * __vend =
std :: __add_grouping ( & __value [ 0 ] , __lc -> _M_thousands_sep ,
__lc -> _M_grouping ,
__lc -> _M_grouping_size ,
__beg , __beg + __paddec ) ;
__value . erase ( __vend - & __value [ 0 ] ) ;
}
else
__value . assign ( __beg , __paddec ) ;
}


if ( __lc -> _M_frac_digits > 0 )
{
__value += __lc -> _M_decimal_point ;
if ( __paddec >= 0 )
__value . append ( __beg + __paddec , __lc -> _M_frac_digits ) ;
else
{

__value . append ( - __paddec , __lit [ money_base :: _S_zero ] ) ;
__value . append ( __beg , __len ) ;
}
}


const ios_base :: fmtflags __f = __io . flags ( )
& ios_base :: adjustfield ;
__len = __value . size ( ) + __sign_size ;
__len += ( ( __io . flags ( ) & ios_base :: showbase )
? __lc -> _M_curr_symbol_size : 0 ) ;

string_type __res ;
__res . reserve ( 2 * __len ) ;

const size_type __width = static_cast < size_type > ( __io . width ( ) ) ;
const bool __testipad = ( __f == ios_base :: internal
&& __len < __width ) ;

for ( int __i = 0 ; __i < 4 ; ++ __i )
{
const part __which = static_cast < part > ( __p . field [ __i ] ) ;
switch ( __which )
{
case money_base :: symbol :
if ( __io . flags ( ) & ios_base :: showbase )
__res . append ( __lc -> _M_curr_symbol ,
__lc -> _M_curr_symbol_size ) ;
break ;
case money_base :: sign :



if ( __sign_size )
__res += __sign [ 0 ] ;
break ;
case money_base :: value :
__res += __value ;
break ;
case money_base :: space :



if ( __testipad )
__res . append ( __width - __len , __fill ) ;
else
__res += __fill ;
break ;
case money_base :: none :
if ( __testipad )
__res . append ( __width - __len , __fill ) ;
break ;
}
}


if ( __sign_size > 1 )
__res . append ( __sign + 1 , __sign_size - 1 ) ;


__len = __res . size ( ) ;
if ( __width > __len )
{
if ( __f == ios_base :: left )

__res . append ( __width - __len , __fill ) ;
else

__res . insert ( 0 , __width - __len , __fill ) ;
__len = __width ;
}


__s = std :: __write ( __s , __res . data ( ) , __len ) ;
}
__io . width ( 0 ) ;
return __s ;
}
#567
template < typename _CharT , typename _OutIter >
_OutIter
money_put < _CharT , _OutIter > ::
do_put ( iter_type __s , bool __intl , ios_base & __io , char_type __fill ,
long double __units ) const
{
const locale __loc = __io . getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;


int __cs_size = 64 ;
char * __cs = static_cast < char * > ( __builtin_alloca ( __cs_size ) ) ;


int __len = std :: __convert_from_v ( _S_get_c_locale ( ) , __cs , __cs_size ,
"%.*Lf" , 0 , __units ) ;

if ( __len >= __cs_size )
{
__cs_size = __len + 1 ;
__cs = static_cast < char * > ( __builtin_alloca ( __cs_size ) ) ;
__len = std :: __convert_from_v ( _S_get_c_locale ( ) , __cs , __cs_size ,
"%.*Lf" , 0 , __units ) ;
}
#599
string_type __digits ( __len , char_type ( ) ) ;
__ctype . widen ( __cs , __cs + __len , & __digits [ 0 ] ) ;
return __intl ? _M_insert < true > ( __s , __io , __fill , __digits )
: _M_insert < false > ( __s , __io , __fill , __digits ) ;
}

template < typename _CharT , typename _OutIter >
_OutIter
money_put < _CharT , _OutIter > ::
do_put ( iter_type __s , bool __intl , ios_base & __io , char_type __fill ,
const string_type & __digits ) const
{ return __intl ? _M_insert < true > ( __s , __io , __fill , __digits )
: _M_insert < false > ( __s , __io , __fill , __digits ) ; }
#618
template < typename _CharT , typename _InIter >
time_base :: dateorder
time_get < _CharT , _InIter > :: do_date_order ( ) const
{ return time_base :: no_order ; }



template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
_M_extract_via_format ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ,
const _CharT * __format ) const
{
const locale & __loc = __io . _M_getloc ( ) ;
const __timepunct < _CharT > & __tp = use_facet < __timepunct < _CharT > > ( __loc ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;
const size_t __len = char_traits < _CharT > :: length ( __format ) ;

ios_base :: iostate __tmperr = ios_base :: goodbit ;
size_t __i = 0 ;
for ( ; __beg != __end && __i < __len && ! __tmperr ; ++ __i )
{
if ( __ctype . narrow ( __format [ __i ] , 0 ) == '%' )
{

char __c = __ctype . narrow ( __format [ ++ __i ] , 0 ) ;
int __mem = 0 ;
if ( __c == 'E' || __c == 'O' )
__c = __ctype . narrow ( __format [ ++ __i ] , 0 ) ;
switch ( __c )
{
const char * __cs ;
_CharT __wcs [ 10 ] ;
case 'a' :

const char_type * __days1 [ 7 ] ;
__tp . _M_days_abbreviated ( __days1 ) ;
__beg = _M_extract_name ( __beg , __end , __tm -> tm_wday , __days1 ,
7 , __io , __tmperr ) ;
break ;
case 'A' :

const char_type * __days2 [ 7 ] ;
__tp . _M_days ( __days2 ) ;
__beg = _M_extract_name ( __beg , __end , __tm -> tm_wday , __days2 ,
7 , __io , __tmperr ) ;
break ;
case 'h' :
case 'b' :

const char_type * __months1 [ 12 ] ;
__tp . _M_months_abbreviated ( __months1 ) ;
__beg = _M_extract_name ( __beg , __end , __tm -> tm_mon ,
__months1 , 12 , __io , __tmperr ) ;
break ;
case 'B' :

const char_type * __months2 [ 12 ] ;
__tp . _M_months ( __months2 ) ;
__beg = _M_extract_name ( __beg , __end , __tm -> tm_mon ,
__months2 , 12 , __io , __tmperr ) ;
break ;
case 'c' :

const char_type * __dt [ 2 ] ;
__tp . _M_date_time_formats ( __dt ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __tmperr ,
__tm , __dt [ 0 ] ) ;
break ;
case 'd' :

__beg = _M_extract_num ( __beg , __end , __tm -> tm_mday , 1 , 31 , 2 ,
__io , __tmperr ) ;
break ;
case 'e' :


if ( __ctype . is ( ctype_base :: space , * __beg ) )
__beg = _M_extract_num ( ++ __beg , __end , __tm -> tm_mday , 1 , 9 ,
1 , __io , __tmperr ) ;
else
__beg = _M_extract_num ( __beg , __end , __tm -> tm_mday , 10 , 31 ,
2 , __io , __tmperr ) ;
break ;
case 'D' :

__cs = "%m/%d/%y" ;
__ctype . widen ( __cs , __cs + 9 , __wcs ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __tmperr ,
__tm , __wcs ) ;
break ;
case 'H' :

__beg = _M_extract_num ( __beg , __end , __tm -> tm_hour , 0 , 23 , 2 ,
__io , __tmperr ) ;
break ;
case 'I' :

__beg = _M_extract_num ( __beg , __end , __tm -> tm_hour , 1 , 12 , 2 ,
__io , __tmperr ) ;
break ;
case 'm' :

__beg = _M_extract_num ( __beg , __end , __mem , 1 , 12 , 2 ,
__io , __tmperr ) ;
if ( ! __tmperr )
__tm -> tm_mon = __mem - 1 ;
break ;
case 'M' :

__beg = _M_extract_num ( __beg , __end , __tm -> tm_min , 0 , 59 , 2 ,
__io , __tmperr ) ;
break ;
case 'n' :
if ( __ctype . narrow ( * __beg , 0 ) == '\n' )
++ __beg ;
else
__tmperr |= ios_base :: failbit ;
break ;
case 'R' :

__cs = "%H:%M" ;
__ctype . widen ( __cs , __cs + 6 , __wcs ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __tmperr ,
__tm , __wcs ) ;
break ;
case 'S' :



__beg = _M_extract_num ( __beg , __end , __tm -> tm_sec , 0 , 60 , 2 ,



__io , __tmperr ) ;
break ;
case 't' :
if ( __ctype . narrow ( * __beg , 0 ) == '\t' )
++ __beg ;
else
__tmperr |= ios_base :: failbit ;
break ;
case 'T' :

__cs = "%H:%M:%S" ;
__ctype . widen ( __cs , __cs + 9 , __wcs ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __tmperr ,
__tm , __wcs ) ;
break ;
case 'x' :

const char_type * __dates [ 2 ] ;
__tp . _M_date_formats ( __dates ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __tmperr ,
__tm , __dates [ 0 ] ) ;
break ;
case 'X' :

const char_type * __times [ 2 ] ;
__tp . _M_time_formats ( __times ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __tmperr ,
__tm , __times [ 0 ] ) ;
break ;
case 'y' :
case 'C' :

case 'Y' :




__beg = _M_extract_num ( __beg , __end , __mem , 0 , 9999 , 4 ,
__io , __tmperr ) ;
if ( ! __tmperr )
__tm -> tm_year = __mem < 0 ? __mem + 100 : __mem - 1900 ;
break ;
case 'Z' :

if ( __ctype . is ( ctype_base :: upper , * __beg ) )
{
int __tmp ;
__beg = _M_extract_name ( __beg , __end , __tmp ,
__timepunct_cache < _CharT > :: _S_timezones ,
14 , __io , __tmperr ) ;


if ( __beg != __end && ! __tmperr && __tmp == 0
&& ( * __beg == __ctype . widen ( '-' )
|| * __beg == __ctype . widen ( '+' ) ) )
{
__beg = _M_extract_num ( __beg , __end , __tmp , 0 , 23 , 2 ,
__io , __tmperr ) ;
__beg = _M_extract_num ( __beg , __end , __tmp , 0 , 59 , 2 ,
__io , __tmperr ) ;
}
}
else
__tmperr |= ios_base :: failbit ;
break ;
default :

__tmperr |= ios_base :: failbit ;
}
}
else
{

if ( __format [ __i ] == * __beg )
++ __beg ;
else
__tmperr |= ios_base :: failbit ;
}
}

if ( __tmperr || __i != __len )
__err |= ios_base :: failbit ;

return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
_M_extract_num ( iter_type __beg , iter_type __end , int & __member ,
int __min , int __max , size_t __len ,
ios_base & __io , ios_base :: iostate & __err ) const
{
const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;


int __mult = __len == 2 ? 10 : ( __len == 4 ? 1000 : 1 ) ;

++ __min ;
size_t __i = 0 ;
int __value = 0 ;
for ( ; __beg != __end && __i < __len ; ++ __beg , ++ __i )
{
const char __c = __ctype . narrow ( * __beg , '*' ) ;
if ( __c >= '0' && __c <= '9' )
{
__value = __value * 10 + ( __c - '0' ) ;
const int __valuec = __value * __mult ;
if ( __valuec > __max || __valuec + __mult < __min )
break ;
__mult /= 10 ;
}
else
break ;
}
if ( __i == __len )
__member = __value ;

else if ( __len == 4 && __i == 2 )
__member = __value - 100 ;
else
__err |= ios_base :: failbit ;

return __beg ;
}



template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
_M_extract_name ( iter_type __beg , iter_type __end , int & __member ,
const _CharT * * __names , size_t __indexlen ,
ios_base & __io , ios_base :: iostate & __err ) const
{
typedef char_traits < _CharT > __traits_type ;
const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;

int * __matches = static_cast < int * > ( __builtin_alloca ( sizeof ( int )
* __indexlen ) ) ;
size_t __nmatches = 0 ;
size_t __pos = 0 ;
bool __testvalid = true ;
const char_type * __name ;





if ( __beg != __end )
{
const char_type __c = * __beg ;
for ( size_t __i1 = 0 ; __i1 < __indexlen ; ++ __i1 )
if ( __c == __names [ __i1 ] [ 0 ]
|| __c == __ctype . toupper ( __names [ __i1 ] [ 0 ] ) )
__matches [ __nmatches ++ ] = __i1 ;
}

while ( __nmatches > 1 )
{

size_t __minlen = __traits_type :: length ( __names [ __matches [ 0 ] ] ) ;
for ( size_t __i2 = 1 ; __i2 < __nmatches ; ++ __i2 )
__minlen = std :: min ( __minlen ,
__traits_type :: length ( __names [ __matches [ __i2 ] ] ) ) ;
++ __beg , ++ __pos ;
if ( __pos < __minlen && __beg != __end )
for ( size_t __i3 = 0 ; __i3 < __nmatches ; )
{
__name = __names [ __matches [ __i3 ] ] ;
if ( ! ( __name [ __pos ] == * __beg ) )
__matches [ __i3 ] = __matches [ -- __nmatches ] ;
else
++ __i3 ;
}
else
break ;
}

if ( __nmatches == 1 )
{

++ __beg , ++ __pos ;
__name = __names [ __matches [ 0 ] ] ;
const size_t __len = __traits_type :: length ( __name ) ;
while ( __pos < __len && __beg != __end && __name [ __pos ] == * __beg )
++ __beg , ++ __pos ;

if ( __len == __pos )
__member = __matches [ 0 ] ;
else
__testvalid = false ;
}
else
__testvalid = false ;
if ( ! __testvalid )
__err |= ios_base :: failbit ;

return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
_M_extract_wday_or_month ( iter_type __beg , iter_type __end , int & __member ,
const _CharT * * __names , size_t __indexlen ,
ios_base & __io , ios_base :: iostate & __err ) const
{
typedef char_traits < _CharT > __traits_type ;
const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;

int * __matches = static_cast < int * > ( __builtin_alloca ( 2 * sizeof ( int )
* __indexlen ) ) ;
size_t __nmatches = 0 ;
size_t * __matches_lengths = 0 ;
size_t __pos = 0 ;

if ( __beg != __end )
{
const char_type __c = * __beg ;
for ( size_t __i = 0 ; __i < 2 * __indexlen ; ++ __i )
if ( __c == __names [ __i ] [ 0 ]
|| __c == __ctype . toupper ( __names [ __i ] [ 0 ] ) )
__matches [ __nmatches ++ ] = __i ;
}

if ( __nmatches )
{
++ __beg , ++ __pos ;

__matches_lengths
= static_cast < size_t * > ( __builtin_alloca ( sizeof ( size_t )
* __nmatches ) ) ;
for ( size_t __i = 0 ; __i < __nmatches ; ++ __i )
__matches_lengths [ __i ]
= __traits_type :: length ( __names [ __matches [ __i ] ] ) ;
}

for ( ; __beg != __end ; ++ __beg , ++ __pos )
{
size_t __nskipped = 0 ;
const char_type __c = * __beg ;
for ( size_t __i = 0 ; __i < __nmatches ; )
{
const char_type * __name = __names [ __matches [ __i ] ] ;
if ( __pos >= __matches_lengths [ __i ] )
++ __nskipped , ++ __i ;
else if ( ! ( __name [ __pos ] == __c ) )
{
-- __nmatches ;
__matches [ __i ] = __matches [ __nmatches ] ;
__matches_lengths [ __i ] = __matches_lengths [ __nmatches ] ;
}
else
++ __i ;
}
if ( __nskipped == __nmatches )
break ;
}

if ( ( __nmatches == 1 && __matches_lengths [ 0 ] == __pos )
|| ( __nmatches == 2 && ( __matches_lengths [ 0 ] == __pos
|| __matches_lengths [ 1 ] == __pos ) ) )
__member = ( __matches [ 0 ] >= __indexlen
? __matches [ 0 ] - __indexlen : __matches [ 0 ] ) ;
else
__err |= ios_base :: failbit ;

return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
do_get_time ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{
const locale & __loc = __io . _M_getloc ( ) ;
const __timepunct < _CharT > & __tp = use_facet < __timepunct < _CharT > > ( __loc ) ;
const char_type * __times [ 2 ] ;
__tp . _M_time_formats ( __times ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __err ,
__tm , __times [ 0 ] ) ;
if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
do_get_date ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{
const locale & __loc = __io . _M_getloc ( ) ;
const __timepunct < _CharT > & __tp = use_facet < __timepunct < _CharT > > ( __loc ) ;
const char_type * __dates [ 2 ] ;
__tp . _M_date_formats ( __dates ) ;
__beg = _M_extract_via_format ( __beg , __end , __io , __err ,
__tm , __dates [ 0 ] ) ;
if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
do_get_weekday ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{
typedef char_traits < _CharT > __traits_type ;
const locale & __loc = __io . _M_getloc ( ) ;
const __timepunct < _CharT > & __tp = use_facet < __timepunct < _CharT > > ( __loc ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;
const char_type * __days [ 14 ] ;
__tp . _M_days_abbreviated ( __days ) ;
__tp . _M_days ( __days + 7 ) ;
int __tmpwday ;
ios_base :: iostate __tmperr = ios_base :: goodbit ;

__beg = _M_extract_wday_or_month ( __beg , __end , __tmpwday , __days , 7 ,
__io , __tmperr ) ;
if ( ! __tmperr )
__tm -> tm_wday = __tmpwday ;
else
__err |= ios_base :: failbit ;

if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
do_get_monthname ( iter_type __beg , iter_type __end ,
ios_base & __io , ios_base :: iostate & __err , tm * __tm ) const
{
typedef char_traits < _CharT > __traits_type ;
const locale & __loc = __io . _M_getloc ( ) ;
const __timepunct < _CharT > & __tp = use_facet < __timepunct < _CharT > > ( __loc ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;
const char_type * __months [ 24 ] ;
__tp . _M_months_abbreviated ( __months ) ;
__tp . _M_months ( __months + 12 ) ;
int __tmpmon ;
ios_base :: iostate __tmperr = ios_base :: goodbit ;

__beg = _M_extract_wday_or_month ( __beg , __end , __tmpmon , __months , 12 ,
__io , __tmperr ) ;
if ( ! __tmperr )
__tm -> tm_mon = __tmpmon ;
else
__err |= ios_base :: failbit ;

if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}

template < typename _CharT , typename _InIter >
_InIter
time_get < _CharT , _InIter > ::
do_get_year ( iter_type __beg , iter_type __end , ios_base & __io ,
ios_base :: iostate & __err , tm * __tm ) const
{
const locale & __loc = __io . _M_getloc ( ) ;
const ctype < _CharT > & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;
int __tmpyear ;
ios_base :: iostate __tmperr = ios_base :: goodbit ;

__beg = _M_extract_num ( __beg , __end , __tmpyear , 0 , 9999 , 4 ,
__io , __tmperr ) ;
if ( ! __tmperr )
__tm -> tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900 ;
else
__err |= ios_base :: failbit ;

if ( __beg == __end )
__err |= ios_base :: eofbit ;
return __beg ;
}

template < typename _CharT , typename _OutIter >
_OutIter
time_put < _CharT , _OutIter > ::
put ( iter_type __s , ios_base & __io , char_type __fill , const tm * __tm ,
const _CharT * __beg , const _CharT * __end ) const
{
const locale & __loc = __io . _M_getloc ( ) ;
ctype < _CharT > const & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;
for ( ; __beg != __end ; ++ __beg )
if ( __ctype . narrow ( * __beg , 0 ) != '%' )
{
* __s = * __beg ;
++ __s ;
}
else if ( ++ __beg != __end )
{
char __format ;
char __mod = 0 ;
const char __c = __ctype . narrow ( * __beg , 0 ) ;
if ( __c != 'E' && __c != 'O' )
__format = __c ;
else if ( ++ __beg != __end )
{
__mod = __c ;
__format = __ctype . narrow ( * __beg , 0 ) ;
}
else
break ;
__s = this -> do_put ( __s , __io , __fill , __tm , __format , __mod ) ;
}
else
break ;
return __s ;
}

template < typename _CharT , typename _OutIter >
_OutIter
time_put < _CharT , _OutIter > ::
do_put ( iter_type __s , ios_base & __io , char_type , const tm * __tm ,
char __format , char __mod ) const
{
const locale & __loc = __io . _M_getloc ( ) ;
ctype < _CharT > const & __ctype = use_facet < ctype < _CharT > > ( __loc ) ;
__timepunct < _CharT > const & __tp = use_facet < __timepunct < _CharT > > ( __loc ) ;



const size_t __maxlen = 128 ;
char_type __res [ __maxlen ] ;
#1195
char_type __fmt [ 4 ] ;
__fmt [ 0 ] = __ctype . widen ( '%' ) ;
if ( ! __mod )
{
__fmt [ 1 ] = __format ;
__fmt [ 2 ] = char_type ( ) ;
}
else
{
__fmt [ 1 ] = __mod ;
__fmt [ 2 ] = __format ;
__fmt [ 3 ] = char_type ( ) ;
}

__tp . _M_put ( __res , __maxlen , __fmt , __tm ) ;


return std :: __write ( __s , __res , char_traits < char_type > :: length ( __res ) ) ;
}





extern template class moneypunct < char , false > ;
extern template class moneypunct < char , true > ;
extern template class moneypunct_byname < char , false > ;
extern template class moneypunct_byname < char , true > ;
extern template class money_get < char > ;
extern template class money_put < char > ;
extern template class __timepunct < char > ;
extern template class time_put < char > ;
extern template class time_put_byname < char > ;
extern template class time_get < char > ;
extern template class time_get_byname < char > ;
extern template class messages < char > ;
extern template class messages_byname < char > ;

extern template
const moneypunct < char , true > &
use_facet < moneypunct < char , true > > ( const locale & ) ;

extern template
const moneypunct < char , false > &
use_facet < moneypunct < char , false > > ( const locale & ) ;

extern template
const money_put < char > &
use_facet < money_put < char > > ( const locale & ) ;

extern template
const money_get < char > &
use_facet < money_get < char > > ( const locale & ) ;

extern template
const __timepunct < char > &
use_facet < __timepunct < char > > ( const locale & ) ;

extern template
const time_put < char > &
use_facet < time_put < char > > ( const locale & ) ;

extern template
const time_get < char > &
use_facet < time_get < char > > ( const locale & ) ;

extern template
const messages < char > &
use_facet < messages < char > > ( const locale & ) ;

extern template
bool
has_facet < moneypunct < char > > ( const locale & ) ;

extern template
bool
has_facet < money_put < char > > ( const locale & ) ;

extern template
bool
has_facet < money_get < char > > ( const locale & ) ;

extern template
bool
has_facet < __timepunct < char > > ( const locale & ) ;

extern template
bool
has_facet < time_put < char > > ( const locale & ) ;

extern template
bool
has_facet < time_get < char > > ( const locale & ) ;

extern template
bool
has_facet < messages < char > > ( const locale & ) ;


extern template class moneypunct < wchar_t , false > ;
extern template class moneypunct < wchar_t , true > ;
extern template class moneypunct_byname < wchar_t , false > ;
extern template class moneypunct_byname < wchar_t , true > ;
extern template class money_get < wchar_t > ;
extern template class money_put < wchar_t > ;
extern template class __timepunct < wchar_t > ;
extern template class time_put < wchar_t > ;
extern template class time_put_byname < wchar_t > ;
extern template class time_get < wchar_t > ;
extern template class time_get_byname < wchar_t > ;
extern template class messages < wchar_t > ;
extern template class messages_byname < wchar_t > ;

extern template
const moneypunct < wchar_t , true > &
use_facet < moneypunct < wchar_t , true > > ( const locale & ) ;

extern template
const moneypunct < wchar_t , false > &
use_facet < moneypunct < wchar_t , false > > ( const locale & ) ;

extern template
const money_put < wchar_t > &
use_facet < money_put < wchar_t > > ( const locale & ) ;

extern template
const money_get < wchar_t > &
use_facet < money_get < wchar_t > > ( const locale & ) ;

extern template
const __timepunct < wchar_t > &
use_facet < __timepunct < wchar_t > > ( const locale & ) ;

extern template
const time_put < wchar_t > &
use_facet < time_put < wchar_t > > ( const locale & ) ;

extern template
const time_get < wchar_t > &
use_facet < time_get < wchar_t > > ( const locale & ) ;

extern template
const messages < wchar_t > &
use_facet < messages < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < moneypunct < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < money_put < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < money_get < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < __timepunct < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < time_put < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < time_get < wchar_t > > ( const locale & ) ;

extern template
bool
has_facet < messages < wchar_t > > ( const locale & ) ;




}
#55 "./boost/regex/v4/regex_workaround.hpp"
namespace boost { namespace re_detail {





using std :: distance ;

} }
#97
namespace boost { namespace re_detail {
#104
template < class T >
inline void pointer_destroy ( T * p )
{ p -> ~ T ( ) ; ( void ) p ; }





template < class T >
inline void pointer_construct ( T * p , const T & t )
{ new ( p ) T ( t ) ; }

} }
#126
namespace boost { namespace re_detail {
#184
using std :: copy ;
using std :: equal ;
#193
inline std :: size_t strcpy_s (
char * strDestination ,
std :: size_t sizeInBytes ,
const char * strSource
)
{
if ( std :: strlen ( strSource ) + 1 > sizeInBytes )
return 1 ;
std :: strcpy ( strDestination , strSource ) ;
return 0 ;
}
inline std :: size_t strcat_s (
char * strDestination ,
std :: size_t sizeInBytes ,
const char * strSource
)
{
if ( std :: strlen ( strSource ) + std :: strlen ( strDestination ) + 1 > sizeInBytes )
return 1 ;
std :: strcat ( strDestination , strSource ) ;
return 0 ;
}



inline void overflow_error_if_not_zero ( std :: size_t i )
{
if ( i )
{
std :: overflow_error e ( "String buffer too small" ) ;
boost :: throw_exception ( e ) ;
}
}

} }
#1 "./boost/regex_fwd.hpp"
#1 "./boost/regex/v4/regex_fwd.hpp"
#37
namespace boost {

template < class charT >
class cpp_regex_traits ;
template < class charT >
struct c_regex_traits ;
template < class charT >
class w32_regex_traits ;





template < class charT , class implementationT = cpp_regex_traits < charT > >
struct regex_traits ;





template < class charT , class traits = regex_traits < charT > >
class basic_regex ;

typedef basic_regex < char , regex_traits < char > > regex ;

typedef basic_regex < wchar_t , regex_traits < wchar_t > > wregex ;


}
#1 "./boost/regex/regex_traits.hpp"
#1 "./boost/regex/v4/regex_traits.hpp"
#1 "./boost/regex/v4/syntax_type.hpp"
#22
namespace boost {
namespace regex_constants {

typedef unsigned char syntax_type ;




static const syntax_type syntax_char = 0 ;
static const syntax_type syntax_open_mark = 1 ;
static const syntax_type syntax_close_mark = 2 ;
static const syntax_type syntax_dollar = 3 ;
static const syntax_type syntax_caret = 4 ;
static const syntax_type syntax_dot = 5 ;
static const syntax_type syntax_star = 6 ;
static const syntax_type syntax_plus = 7 ;
static const syntax_type syntax_question = 8 ;
static const syntax_type syntax_open_set = 9 ;
static const syntax_type syntax_close_set = 10 ;
static const syntax_type syntax_or = 11 ;
static const syntax_type syntax_escape = 12 ;
static const syntax_type syntax_dash = 14 ;
static const syntax_type syntax_open_brace = 15 ;
static const syntax_type syntax_close_brace = 16 ;
static const syntax_type syntax_digit = 17 ;
static const syntax_type syntax_comma = 27 ;
static const syntax_type syntax_equal = 37 ;
static const syntax_type syntax_colon = 36 ;
static const syntax_type syntax_not = 53 ;



static const syntax_type syntax_hash = 13 ;
static const syntax_type syntax_newline = 26 ;



typedef syntax_type escape_syntax_type ;

static const escape_syntax_type escape_type_word_assert = 18 ;
static const escape_syntax_type escape_type_not_word_assert = 19 ;
static const escape_syntax_type escape_type_control_f = 29 ;
static const escape_syntax_type escape_type_control_n = 30 ;
static const escape_syntax_type escape_type_control_r = 31 ;
static const escape_syntax_type escape_type_control_t = 32 ;
static const escape_syntax_type escape_type_control_v = 33 ;
static const escape_syntax_type escape_type_ascii_control = 35 ;
static const escape_syntax_type escape_type_hex = 34 ;
static const escape_syntax_type escape_type_unicode = 0 ;
static const escape_syntax_type escape_type_identity = 0 ;
static const escape_syntax_type escape_type_backref = syntax_digit ;
static const escape_syntax_type escape_type_decimal = syntax_digit ;
static const escape_syntax_type escape_type_class = 22 ;
static const escape_syntax_type escape_type_not_class = 23 ;



static const escape_syntax_type escape_type_left_word = 20 ;
static const escape_syntax_type escape_type_right_word = 21 ;
static const escape_syntax_type escape_type_start_buffer = 24 ;
static const escape_syntax_type escape_type_end_buffer = 25 ;
static const escape_syntax_type escape_type_control_a = 28 ;
static const escape_syntax_type escape_type_e = 38 ;
static const escape_syntax_type escape_type_E = 47 ;
static const escape_syntax_type escape_type_Q = 48 ;
static const escape_syntax_type escape_type_X = 49 ;
static const escape_syntax_type escape_type_C = 50 ;
static const escape_syntax_type escape_type_Z = 51 ;
static const escape_syntax_type escape_type_G = 52 ;

static const escape_syntax_type escape_type_property = 54 ;
static const escape_syntax_type escape_type_not_property = 55 ;
static const escape_syntax_type escape_type_named_char = 56 ;
static const escape_syntax_type escape_type_extended_backref = 57 ;
static const escape_syntax_type escape_type_reset_start_mark = 58 ;
static const escape_syntax_type escape_type_line_ending = 59 ;

static const escape_syntax_type syntax_max = 60 ;

}
}
#1 "./boost/regex/v4/error_type.hpp"
#23
namespace boost {



namespace regex_constants {

enum error_type {

error_ok = 0 ,
error_no_match = 1 ,
error_bad_pattern = 2 ,
error_collate = 3 ,
error_ctype = 4 ,
error_escape = 5 ,
error_backref = 6 ,
error_brack = 7 ,
error_paren = 8 ,
error_brace = 9 ,
error_badbrace = 10 ,
error_range = 11 ,
error_space = 12 ,
error_badrepeat = 13 ,
error_end = 14 ,
error_size = 15 ,
error_right_paren = 16 ,
error_empty = 17 ,
error_complexity = 18 ,
error_stack = 19 ,
error_perl_extension = 20 ,
error_unknown = 21
} ;

}
}
#1 "./boost/regex/v4/regex_traits_defaults.hpp"
#46
namespace boost { namespace re_detail {





template < class charT >
inline bool is_extended ( charT c )
{ return c > 256 ; }
inline bool is_extended ( char )
{ return false ; }


const char * get_default_syntax ( regex_constants :: syntax_type n ) ;
const char * get_default_error_string ( regex_constants :: error_type n ) ;
regex_constants :: syntax_type get_default_syntax_type ( char c ) ;
regex_constants :: escape_syntax_type get_default_escape_syntax_type ( char c ) ;


bool is_combining_implementation ( uint_least16_t s ) ;

template < class charT >
inline bool is_combining ( charT c )
{
return ( c <= static_cast < charT > ( 0 ) ) ? false : ( ( c >= static_cast < charT > ( ( std :: numeric_limits < uint_least16_t
#70
> :: max ) ( ) ) ) ? false : is_combining_implementation ( static_cast < unsigned short > ( c ) ) ) ;
}
template < >
inline bool is_combining < char > ( char )
{
return false ;
}
template < >
inline bool is_combining < signed char > ( signed char )
{
return false ;
}
template < >
inline bool is_combining < unsigned char > ( unsigned char )
{
return false ;
}
#114
template < class charT >
inline bool is_separator ( charT c )
{
return





static_cast < bool > ( ( c == static_cast < charT > ( '\n' ) ) || ( c == static_cast < charT > ( '\r' ) ) || ( c == static_cast
#123
< charT > ( '\f' ) ) || ( static_cast < boost :: uint16_t > ( c ) == 0x2028u ) || ( static_cast < boost :: uint16_t > ( c
#123
) == 0x2029u ) || ( static_cast < boost :: uint16_t > ( c ) == 0x85u ) ) ;
}
template < >
inline bool is_separator < char > ( char c )
{
return static_cast < bool > ( ( c == '\n' ) || ( c == '\r' ) || ( c == '\f' ) ) ;
}




std :: string lookup_default_collate_name ( const std :: string & name ) ;





template < class charT >
struct character_pointer_range
{
const charT * p1 ;
const charT * p2 ;

bool operator < ( const character_pointer_range & r ) const
{
return std :: lexicographical_compare ( p1 , p2 , r . p1 , r . p2 ) ;
}
bool operator == ( const character_pointer_range & r ) const
{




return ( ( p2 - p1 ) == ( r . p2 - r . p1 ) ) && re_detail :: equal ( p1 , p2 , r . p1 ) ;
}
} ;
template < class charT >
int get_default_class_id ( const charT * p1 , const charT * p2 )
{
static const charT data [ 73 ] = {
'a' , 'l' , 'n' , 'u' , 'm' ,
'a' , 'l' , 'p' , 'h' , 'a' ,
'b' , 'l' , 'a' , 'n' , 'k' ,
'c' , 'n' , 't' , 'r' , 'l' ,
'd' , 'i' , 'g' , 'i' , 't' ,
'g' , 'r' , 'a' , 'p' , 'h' ,
'l' , 'o' , 'w' , 'e' , 'r' ,
'p' , 'r' , 'i' , 'n' , 't' ,
'p' , 'u' , 'n' , 'c' , 't' ,
's' , 'p' , 'a' , 'c' , 'e' ,
'u' , 'n' , 'i' , 'c' , 'o' , 'd' , 'e' ,
'u' , 'p' , 'p' , 'e' , 'r' ,
'v' ,
'w' , 'o' , 'r' , 'd' ,
'x' , 'd' , 'i' , 'g' , 'i' , 't' ,
} ;

static const character_pointer_range < charT > ranges [ 21 ] =
{
{ data + 0 , data + 5 , } ,
{ data + 5 , data + 10 , } ,
{ data + 10 , data + 15 , } ,
{ data + 15 , data + 20 , } ,
{ data + 20 , data + 21 , } ,
{ data + 20 , data + 25 , } ,
{ data + 25 , data + 30 , } ,
{ data + 29 , data + 30 , } ,
{ data + 30 , data + 31 , } ,
{ data + 30 , data + 35 , } ,
{ data + 35 , data + 40 , } ,
{ data + 40 , data + 45 , } ,
{ data + 45 , data + 46 , } ,
{ data + 45 , data + 50 , } ,
{ data + 57 , data + 58 , } ,
{ data + 50 , data + 57 , } ,
{ data + 57 , data + 62 , } ,
{ data + 62 , data + 63 , } ,
{ data + 63 , data + 64 , } ,
{ data + 63 , data + 67 , } ,
{ data + 67 , data + 73 , } ,
} ;
static const character_pointer_range < charT > * ranges_begin = ranges ;
static const character_pointer_range < charT > * ranges_end = ranges + ( sizeof ( ranges ) / sizeof ( ranges [ 0 ] ) ) ;
#205


character_pointer_range < charT > t = { p1 , p2 , } ;
const character_pointer_range < charT > * p = std :: lower_bound ( ranges_begin , ranges_end , t ) ;
if ( ( p != ranges_end ) && ( t == * p ) )
return static_cast < int > ( p - ranges ) ;
return - 1 ;
}




template < class charT >
std :: ptrdiff_t global_length ( const charT * p )
{
std :: ptrdiff_t n = 0 ;
while ( * p )
{
++ p ;
++ n ;
}
return n ;
}
template < >
inline std :: ptrdiff_t global_length < char > ( const char * p )
{
return ( std :: strlen ) ( p ) ;
}

template < >
inline std :: ptrdiff_t global_length < wchar_t > ( const wchar_t * p )
{
return ( std :: wcslen ) ( p ) ;
}

template < class charT >
inline charT global_lower ( charT c )
{
return c ;
}
template < class charT >
inline charT global_upper ( charT c )
{
return c ;
}

char do_global_lower ( char c ) ;
char do_global_upper ( char c ) ;

wchar_t do_global_lower ( wchar_t c ) ;
wchar_t do_global_upper ( wchar_t c ) ;
#271
template < > inline char global_lower < char > ( char c ) { return do_global_lower ( c ) ; }
template < > inline char global_upper < char > ( char c ) { return do_global_upper ( c ) ; }

template < > inline wchar_t global_lower < wchar_t > ( wchar_t c ) { return do_global_lower ( c ) ; }
template < > inline wchar_t global_upper < wchar_t > ( wchar_t c ) { return do_global_upper ( c ) ; }
#282
template < class charT >
int global_value ( charT c )
{
static const charT zero = '0' ;
static const charT nine = '9' ;
static const charT a = 'a' ;
static const charT f = 'f' ;
static const charT A = 'A' ;
static const charT F = 'F' ;

if ( c > f ) return - 1 ;
if ( c >= a ) return 10 + ( c - a ) ;
if ( c > F ) return - 1 ;
if ( c >= A ) return 10 + ( c - A ) ;
if ( c > nine ) return - 1 ;
if ( c >= zero ) return c - zero ;
return - 1 ;
}
template < class charT , class traits >
int global_toi ( const charT * & p1 , const charT * p2 , int radix , const traits & t )
{
( void ) t ;
int next_value = t . value ( * p1 , radix ) ;
if ( ( p1 == p2 ) || ( next_value < 0 ) || ( next_value >= radix ) )
return - 1 ;
int result = 0 ;
while ( p1 != p2 )
{
next_value = t . value ( * p1 , radix ) ;
if ( ( next_value < 0 ) || ( next_value >= radix ) )
break ;
result *= radix ;
result += next_value ;
++ p1 ;
}
return result ;
}

template < class charT >
inline const charT * get_escape_R_string ( )
{




static const charT e1 [ ] = { '(' , '?' , '>' , '\x0D' , '\x0A' , '?' ,
'|' , '[' , '\x0A' , '\x0B' , '\x0C' , static_cast < unsigned char > ( '\x85' ) , '\\' , 'x' , '{' , '2' , '0' , '2' , '8'
#328
, '}' ,
'\\' , 'x' , '{' , '2' , '0' , '2' , '9' , '}' , ']' , ')' , '\0' } ;
static const charT e2 [ ] = { '(' , '?' , '>' , '\x0D' , '\x0A' , '?' ,
'|' , '[' , '\x0A' , '\x0B' , '\x0C' , static_cast < unsigned char > ( '\x85' ) , ']' , ')' , '\0' } ;

charT c = static_cast < charT > ( 0x2029u ) ;
bool b = ( static_cast < unsigned > ( c ) == 0x2029u ) ;

return ( b ? e1 : e2 ) ;



}

template < >
inline const char * get_escape_R_string < char > ( )
{




static const char e2 [ ] = { '(' , '?' , '>' , '\x0D' , '\x0A' , '?' ,
'|' , '[' , '\x0A' , '\x0B' , '\x0C' , '\x85' , ']' , ')' , '\0' } ;
return e2 ;



}

}
}
#1 "./boost/regex/v4/cpp_regex_traits.hpp"
#1 "./boost/integer.hpp"
#1 "./boost/integer_fwd.hpp"
#1 "./boost/cstdint.hpp"
#20 "./boost/integer_fwd.hpp"
namespace boost
{
#29
typedef boost :: uintmax_t static_min_max_unsigned_type ;
typedef boost :: intmax_t static_min_max_signed_type ;
typedef boost :: uintmax_t static_log2_argument_type ;
typedef int static_log2_result_type ;
#42
template < class T >
class integer_traits ;

template < >
class integer_traits < bool > ;

template < >
class integer_traits < char > ;

template < >
class integer_traits < signed char > ;

template < >
class integer_traits < unsigned char > ;


template < >
class integer_traits < wchar_t > ;


template < >
class integer_traits < short > ;

template < >
class integer_traits < unsigned short > ;

template < >
class integer_traits < int > ;

template < >
class integer_traits < unsigned int > ;

template < >
class integer_traits < long > ;

template < >
class integer_traits < unsigned long > ;


template < >
class integer_traits < :: boost :: long_long_type > ;

template < >
class integer_traits < :: boost :: ulong_long_type > ;
#97
template < typename LeastInt >
struct int_fast_t ;

template < int Bits >
struct int_t ;

template < int Bits >
struct uint_t ;


template < boost :: long_long_type MaxValue >



struct int_max_value_t ;


template < boost :: long_long_type MinValue >



struct int_min_value_t ;


template < boost :: ulong_long_type MaxValue >



struct uint_value_t ;




template < std :: size_t Bit >
struct high_bit_mask_t ;

template < std :: size_t Bits >
struct low_bits_mask_t ;

template < >
struct low_bits_mask_t < :: std :: numeric_limits < unsigned char > :: digits > ;



template < static_log2_argument_type Value >
struct static_log2 ;

template < > struct static_log2 < 0u > ;




template < static_min_max_signed_type Value1 , static_min_max_signed_type Value2 >
struct static_signed_min ;

template < static_min_max_signed_type Value1 , static_min_max_signed_type Value2 >
struct static_signed_max ;

template < static_min_max_unsigned_type Value1 , static_min_max_unsigned_type Value2 >
struct static_unsigned_min ;

template < static_min_max_unsigned_type Value1 , static_min_max_unsigned_type Value2 >
struct static_unsigned_max ;

}
#1 "./boost/integer_traits.hpp"
#42
namespace boost {
template < class T >
class integer_traits : public std :: numeric_limits < T >
{
public :
static const bool is_integral = false ;
} ;

namespace detail {
template < class T , T min_val , T max_val >
class integer_traits_base
{
public :
static const bool is_integral = true ;
static const T const_min = min_val ;
static const T const_max = max_val ;
} ;



template < class T , T min_val , T max_val >
const bool integer_traits_base < T , min_val , max_val > :: is_integral ;

template < class T , T min_val , T max_val >
const T integer_traits_base < T , min_val , max_val > :: const_min ;

template < class T , T min_val , T max_val >
const T integer_traits_base < T , min_val , max_val > :: const_max ;


}

template < >
class integer_traits < bool >
: public std :: numeric_limits < bool > ,
public detail :: integer_traits_base < bool , false , true >
{ } ;

template < >
class integer_traits < char >
: public std :: numeric_limits < char > ,
public detail :: integer_traits_base < char , ( - 128 ) , 127 >
{ } ;

template < >
class integer_traits < signed char >
: public std :: numeric_limits < signed char > ,
public detail :: integer_traits_base < signed char , ( - 128 ) , 127 >
{ } ;

template < >
class integer_traits < unsigned char >
: public std :: numeric_limits < unsigned char > ,
public detail :: integer_traits_base < unsigned char , 0 , 255 >
{ } ;


template < >
class integer_traits < wchar_t >
: public std :: numeric_limits < wchar_t > ,



public detail :: integer_traits_base < wchar_t , ( - 2147483647 - 1 ) , 2147483647 >
#130
{ } ;


template < >
class integer_traits < short >
: public std :: numeric_limits < short > ,
public detail :: integer_traits_base < short , ( - 32768 ) , 32767 >
{ } ;

template < >
class integer_traits < unsigned short >
: public std :: numeric_limits < unsigned short > ,
public detail :: integer_traits_base < unsigned short , 0 , 65535 >
{ } ;

template < >
class integer_traits < int >
: public std :: numeric_limits < int > ,
public detail :: integer_traits_base < int , ( - 2147483647 - 1 ) , 2147483647 >
{ } ;

template < >
class integer_traits < unsigned int >
: public std :: numeric_limits < unsigned int > ,
public detail :: integer_traits_base < unsigned int , 0 , 4294967295U >
{ } ;

template < >
class integer_traits < long >
: public std :: numeric_limits < long > ,
public detail :: integer_traits_base < long , ( - 9223372036854775807L - 1L ) , 9223372036854775807L >
{ } ;

template < >
class integer_traits < unsigned long >
: public std :: numeric_limits < unsigned long > ,
public detail :: integer_traits_base < unsigned long , 0 , 18446744073709551615UL >
{ } ;




template < >
class integer_traits < :: boost :: long_long_type >
: public std :: numeric_limits < :: boost :: long_long_type > ,
public detail :: integer_traits_base < :: boost :: long_long_type , ( - 9223372036854775807LL - 1LL ) , 9223372036854775807LL
#175
>
{ } ;

template < >
class integer_traits < :: boost :: ulong_long_type >
: public std :: numeric_limits < :: boost :: ulong_long_type > ,
public detail :: integer_traits_base < :: boost :: ulong_long_type , 0 , 18446744073709551615ULL >
{ } ;
#256
}
#1 "./boost/cstdint.hpp"
#1 "./boost/static_assert.hpp"
#84
namespace boost {


template < bool x > struct STATIC_ASSERTION_FAILURE ;

template < > struct STATIC_ASSERTION_FAILURE < true > { enum { value = 1 } ; } ;


template < int x > struct static_assert_test { } ;

}
#37 "./boost/integer.hpp"
namespace boost
{





template < typename LeastInt >
struct int_fast_t
{
typedef LeastInt fast ;
typedef fast type ;
} ;

namespace detail {


template < int Category > struct int_least_helper { } ;
template < int Category > struct uint_least_helper { } ;





template < > struct int_least_helper < 1 > { typedef boost :: long_long_type least ; } ;



template < > struct int_least_helper < 2 > { typedef long least ; } ;
template < > struct int_least_helper < 3 > { typedef int least ; } ;
template < > struct int_least_helper < 4 > { typedef short least ; } ;
template < > struct int_least_helper < 5 > { typedef signed char least ; } ;

template < > struct uint_least_helper < 1 > { typedef boost :: ulong_long_type least ; } ;



template < > struct uint_least_helper < 2 > { typedef unsigned long least ; } ;
template < > struct uint_least_helper < 3 > { typedef unsigned int least ; } ;
template < > struct uint_least_helper < 4 > { typedef unsigned short least ; } ;
template < > struct uint_least_helper < 5 > { typedef unsigned char least ; } ;

template < int Bits >
struct exact_signed_base_helper { } ;
template < int Bits >
struct exact_unsigned_base_helper { } ;

template < > struct exact_signed_base_helper < sizeof ( signed char ) * 8 > { typedef signed char exact ; } ;
template < > struct exact_unsigned_base_helper < sizeof ( unsigned char ) * 8 > { typedef unsigned char exact ; } ;

template < > struct exact_signed_base_helper < sizeof ( short ) * 8 > { typedef short exact ; } ;
template < > struct exact_unsigned_base_helper < sizeof ( unsigned short ) * 8 > { typedef unsigned short exact ; } ;


template < > struct exact_signed_base_helper < sizeof ( int ) * 8 > { typedef int exact ; } ;
template < > struct exact_unsigned_base_helper < sizeof ( unsigned int ) * 8 > { typedef unsigned int exact ; } ;


template < > struct exact_signed_base_helper < sizeof ( long ) * 8 > { typedef long exact ; } ;
template < > struct exact_unsigned_base_helper < sizeof ( unsigned long ) * 8 > { typedef unsigned long exact ; } ;
#108
}




template < int Bits >
struct int_t : public detail :: exact_signed_base_helper < Bits >
{

typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( Bits <= ( int ) ( sizeof
#117
( boost :: intmax_t ) * 8 ) ) > ) > boost_static_assert_typedef_117 ;
typedef typename detail :: int_least_helper
<

( Bits <= ( int ) ( sizeof ( boost :: long_long_type ) * 8 ) ) +



( Bits - 1 <= :: std :: numeric_limits < long > :: digits ) +
( Bits - 1 <= :: std :: numeric_limits < int > :: digits ) +
( Bits - 1 <= :: std :: numeric_limits < short > :: digits ) +
( Bits - 1 <= :: std :: numeric_limits < signed char > :: digits )
> :: least least ;
typedef typename int_fast_t < least > :: type fast ;
} ;


template < int Bits >
struct uint_t : public detail :: exact_unsigned_base_helper < Bits >
{

typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( Bits <= ( int ) ( sizeof
#138
( boost :: uintmax_t ) * 8 ) ) > ) > boost_static_assert_typedef_138 ;
#149
typedef typename detail :: uint_least_helper
<

( Bits <= ( int ) ( sizeof ( boost :: long_long_type ) * 8 ) ) +



( Bits <= :: std :: numeric_limits < unsigned long > :: digits ) +
( Bits <= :: std :: numeric_limits < unsigned int > :: digits ) +
( Bits <= :: std :: numeric_limits < unsigned short > :: digits ) +
( Bits <= :: std :: numeric_limits < unsigned char > :: digits )
> :: least least ;

typedef typename int_fast_t < least > :: type fast ;

} ;





template < boost :: long_long_type MaxValue >



struct int_max_value_t
{
typedef typename detail :: int_least_helper
<

( MaxValue <= :: boost :: integer_traits < boost :: long_long_type > :: const_max ) +



( MaxValue <= :: boost :: integer_traits < long > :: const_max ) +
( MaxValue <= :: boost :: integer_traits < int > :: const_max ) +
( MaxValue <= :: boost :: integer_traits < short > :: const_max ) +
( MaxValue <= :: boost :: integer_traits < signed char > :: const_max )
> :: least least ;
typedef typename int_fast_t < least > :: type fast ;
} ;


template < boost :: long_long_type MinValue >



struct int_min_value_t
{
typedef typename detail :: int_least_helper
<

( MinValue >= :: boost :: integer_traits < boost :: long_long_type > :: const_min ) +



( MinValue >= :: boost :: integer_traits < long > :: const_min ) +
( MinValue >= :: boost :: integer_traits < int > :: const_min ) +
( MinValue >= :: boost :: integer_traits < short > :: const_min ) +
( MinValue >= :: boost :: integer_traits < signed char > :: const_min )
> :: least least ;
typedef typename int_fast_t < least > :: type fast ;
} ;



template < boost :: ulong_long_type MaxValue >



struct uint_value_t
{
#242
typedef typename detail :: uint_least_helper
<

( MaxValue <= :: boost :: integer_traits < boost :: ulong_long_type > :: const_max ) +



( MaxValue <= :: boost :: integer_traits < unsigned long > :: const_max ) +
( MaxValue <= :: boost :: integer_traits < unsigned int > :: const_max ) +
( MaxValue <= :: boost :: integer_traits < unsigned short > :: const_max ) +
( MaxValue <= :: boost :: integer_traits < unsigned char > :: const_max )
> :: least least ;

typedef typename int_fast_t < least > :: type fast ;
} ;


}
#1 "./boost/regex/pattern_except.hpp"
#30
namespace boost {
#47
class regex_error : public std :: runtime_error
{
public :
explicit regex_error ( const std :: string & s , regex_constants :: error_type err = regex_constants :: error_unknown , std
#50
:: ptrdiff_t pos = 0 ) ;
explicit regex_error ( regex_constants :: error_type err ) ;
~ regex_error ( ) throw ( ) ;
regex_constants :: error_type code ( ) const
{ return m_error_code ; }
std :: ptrdiff_t position ( ) const
{ return m_position ; }
void raise ( ) const ;
private :
regex_constants :: error_type m_error_code ;
std :: ptrdiff_t m_position ;
} ;

typedef regex_error bad_pattern ;
typedef regex_error bad_expression ;

namespace re_detail {

void raise_runtime_error ( const std :: runtime_error & ex ) ;

template < class traits >
void raise_error ( const traits & t , regex_constants :: error_type code )
{
( void ) t ;
std :: runtime_error e ( t . error_string ( code ) ) ;
:: boost :: re_detail :: raise_runtime_error ( e ) ;
}

}
#95
}
#1 "./boost/regex/pending/static_mutex.hpp"
#37
namespace boost {

class static_mutex ;



class scoped_static_mutex_lock
{
public :
scoped_static_mutex_lock ( static_mutex & mut , bool lk = true ) ;
~ scoped_static_mutex_lock ( ) ;
inline bool locked ( ) const
{
return m_have_lock ;
}
inline operator void const * ( ) const
{
return locked ( ) ? this : 0 ;
}
void lock ( ) ;
void unlock ( ) ;
private :
static_mutex & m_mutex ;
bool m_have_lock ;
} ;

class static_mutex
{
public :
typedef scoped_static_mutex_lock scoped_lock ;
pthread_mutex_t m_mutex ;
} ;

}
#1 "./boost/regex/v4/primary_transform.hpp"
#34
namespace boost {
namespace re_detail {


enum {
sort_C ,
sort_fixed ,
sort_delim ,
sort_unknown
} ;

template < class S , class charT >
unsigned count_chars ( const S & s , charT c )
{
#54
unsigned int count = 0 ;
for ( unsigned pos = 0 ; pos < s . size ( ) ; ++ pos )
{
if ( s [ pos ] == c ) ++ count ;
}
return count ;
}


template < class traits , class charT >
unsigned find_sort_syntax ( const traits * pt , charT * delim )
{




typedef typename traits :: string_type string_type ;
typedef typename traits :: char_type char_type ;


( void ) pt ;

char_type a [ 2 ] = { 'a' , '\0' , } ;
string_type sa ( pt -> transform ( a , a + 1 ) ) ;
if ( sa == a )
{
* delim = 0 ;
return sort_C ;
}
char_type A [ 2 ] = { 'A' , '\0' , } ;
string_type sA ( pt -> transform ( A , A + 1 ) ) ;
char_type c [ 2 ] = { ';' , '\0' , } ;
string_type sc ( pt -> transform ( c , c + 1 ) ) ;

int pos = 0 ;
while ( ( pos <= static_cast < int > ( sa . size ( ) ) ) && ( pos <= static_cast < int > ( sA . size ( ) ) ) && ( sa [ pos
#89
] == sA [ pos ] ) ) ++ pos ;
-- pos ;
if ( pos < 0 )
{
* delim = 0 ;
return sort_unknown ;
}




charT maybe_delim = sa [ pos ] ;
if ( ( pos != 0 ) && ( count_chars ( sa , maybe_delim ) == count_chars ( sA , maybe_delim ) ) && ( count_chars ( sa , maybe_delim
#101
) == count_chars ( sc , maybe_delim ) ) )
{
* delim = maybe_delim ;
return sort_delim ;
}



if ( ( sa . size ( ) == sA . size ( ) ) && ( sa . size ( ) == sc . size ( ) ) )
{



* delim = static_cast < charT > ( ++ pos ) ;
return sort_fixed ;
}



* delim = 0 ;
return sort_unknown ;
}


}
}
#1 "./boost/regex/pending/object_cache.hpp"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/list"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_list.h"
#64
namespace std
{
namespace __detail
{
#77
struct _List_node_base
{
_List_node_base * _M_next ;
_List_node_base * _M_prev ;

static void
swap ( _List_node_base & __x , _List_node_base & __y ) noexcept ;

void
_M_transfer ( _List_node_base * const __first ,
_List_node_base * const __last ) noexcept ;

void
_M_reverse ( ) noexcept ;

void
_M_hook ( _List_node_base * const __position ) noexcept ;

void
_M_unhook ( ) noexcept ;
} ;


}




template < typename _Tp >
struct _List_node : public __detail :: _List_node_base
{

_Tp _M_data ;


template < typename ... _Args >
_List_node ( _Args && ... __args )
: __detail :: _List_node_base ( ) , _M_data ( std :: forward < _Args > ( __args ) ... )
{ }

} ;
#124
template < typename _Tp >
struct _List_iterator
{
typedef _List_iterator < _Tp > _Self ;
typedef _List_node < _Tp > _Node ;

typedef ptrdiff_t difference_type ;
typedef std :: bidirectional_iterator_tag iterator_category ;
typedef _Tp value_type ;
typedef _Tp * pointer ;
typedef _Tp & reference ;

_List_iterator ( )
: _M_node ( ) { }

explicit
_List_iterator ( __detail :: _List_node_base * __x )
: _M_node ( __x ) { }


reference
operator * ( ) const
{ return static_cast < _Node * > ( _M_node ) -> _M_data ; }

pointer
operator -> ( ) const
{ return std :: __addressof ( static_cast < _Node * > ( _M_node ) -> _M_data ) ; }

_Self &
operator ++ ( )
{
_M_node = _M_node -> _M_next ;
return * this ;
}

_Self
operator ++ ( int )
{
_Self __tmp = * this ;
_M_node = _M_node -> _M_next ;
return __tmp ;
}

_Self &
operator -- ( )
{
_M_node = _M_node -> _M_prev ;
return * this ;
}

_Self
operator -- ( int )
{
_Self __tmp = * this ;
_M_node = _M_node -> _M_prev ;
return __tmp ;
}

bool
operator == ( const _Self & __x ) const
{ return _M_node == __x . _M_node ; }

bool
operator != ( const _Self & __x ) const
{ return _M_node != __x . _M_node ; }


__detail :: _List_node_base * _M_node ;
} ;
#199
template < typename _Tp >
struct _List_const_iterator
{
typedef _List_const_iterator < _Tp > _Self ;
typedef const _List_node < _Tp > _Node ;
typedef _List_iterator < _Tp > iterator ;

typedef ptrdiff_t difference_type ;
typedef std :: bidirectional_iterator_tag iterator_category ;
typedef _Tp value_type ;
typedef const _Tp * pointer ;
typedef const _Tp & reference ;

_List_const_iterator ( )
: _M_node ( ) { }

explicit
_List_const_iterator ( const __detail :: _List_node_base * __x )
: _M_node ( __x ) { }

_List_const_iterator ( const iterator & __x )
: _M_node ( __x . _M_node ) { }



reference
operator * ( ) const
{ return static_cast < _Node * > ( _M_node ) -> _M_data ; }

pointer
operator -> ( ) const
{ return std :: __addressof ( static_cast < _Node * > ( _M_node ) -> _M_data ) ; }

_Self &
operator ++ ( )
{
_M_node = _M_node -> _M_next ;
return * this ;
}

_Self
operator ++ ( int )
{
_Self __tmp = * this ;
_M_node = _M_node -> _M_next ;
return __tmp ;
}

_Self &
operator -- ( )
{
_M_node = _M_node -> _M_prev ;
return * this ;
}

_Self
operator -- ( int )
{
_Self __tmp = * this ;
_M_node = _M_node -> _M_prev ;
return __tmp ;
}

bool
operator == ( const _Self & __x ) const
{ return _M_node == __x . _M_node ; }

bool
operator != ( const _Self & __x ) const
{ return _M_node != __x . _M_node ; }


const __detail :: _List_node_base * _M_node ;
} ;

template < typename _Val >
inline bool
operator == ( const _List_iterator < _Val > & __x ,
const _List_const_iterator < _Val > & __y )
{ return __x . _M_node == __y . _M_node ; }

template < typename _Val >
inline bool
operator != ( const _List_iterator < _Val > & __x ,
const _List_const_iterator < _Val > & __y )
{ return __x . _M_node != __y . _M_node ; }



template < typename _Tp , typename _Alloc >
class _List_base
{
protected :
#305
typedef typename _Alloc :: template rebind < _List_node < _Tp > > :: other
_Node_alloc_type ;

typedef typename _Alloc :: template rebind < _Tp > :: other _Tp_alloc_type ;

struct _List_impl
: public _Node_alloc_type
{
__detail :: _List_node_base _M_node ;

_List_impl ( )
: _Node_alloc_type ( ) , _M_node ( )
{ }

_List_impl ( const _Node_alloc_type & __a )
: _Node_alloc_type ( __a ) , _M_node ( )
{ }


_List_impl ( _Node_alloc_type && __a )
: _Node_alloc_type ( std :: move ( __a ) ) , _M_node ( )
{ }

} ;

_List_impl _M_impl ;

_List_node < _Tp > *
_M_get_node ( )
{ return _M_impl . _Node_alloc_type :: allocate ( 1 ) ; }

void
_M_put_node ( _List_node < _Tp > * __p )
{ _M_impl . _Node_alloc_type :: deallocate ( __p , 1 ) ; }

public :
typedef _Alloc allocator_type ;

_Node_alloc_type &
_M_get_Node_allocator ( ) noexcept
{ return * static_cast < _Node_alloc_type * > ( & _M_impl ) ; }

const _Node_alloc_type &
_M_get_Node_allocator ( ) const noexcept
{ return * static_cast < const _Node_alloc_type * > ( & _M_impl ) ; }

_Tp_alloc_type
_M_get_Tp_allocator ( ) const noexcept
{ return _Tp_alloc_type ( _M_get_Node_allocator ( ) ) ; }

allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_get_Node_allocator ( ) ) ; }

_List_base ( )
: _M_impl ( )
{ _M_init ( ) ; }

_List_base ( const _Node_alloc_type & __a )
: _M_impl ( __a )
{ _M_init ( ) ; }


_List_base ( _List_base && __x )
: _M_impl ( std :: move ( __x . _M_get_Node_allocator ( ) ) )
{
_M_init ( ) ;
__detail :: _List_node_base :: swap ( _M_impl . _M_node , __x . _M_impl . _M_node ) ;
}



~ _List_base ( ) noexcept
{ _M_clear ( ) ; }

void
_M_clear ( ) ;

void
_M_init ( )
{
this -> _M_impl . _M_node . _M_next = & this -> _M_impl . _M_node ;
this -> _M_impl . _M_node . _M_prev = & this -> _M_impl . _M_node ;
}
} ;
#437
template < typename _Tp , typename _Alloc = std :: allocator < _Tp > >
class list : protected _List_base < _Tp , _Alloc >
{

typedef typename _Alloc :: value_type _Alloc_value_type ;



typedef _List_base < _Tp , _Alloc > _Base ;
typedef typename _Base :: _Tp_alloc_type _Tp_alloc_type ;
typedef typename _Base :: _Node_alloc_type _Node_alloc_type ;

public :
typedef _Tp value_type ;
typedef typename _Tp_alloc_type :: pointer pointer ;
typedef typename _Tp_alloc_type :: const_pointer const_pointer ;
typedef typename _Tp_alloc_type :: reference reference ;
typedef typename _Tp_alloc_type :: const_reference const_reference ;
typedef _List_iterator < _Tp > iterator ;
typedef _List_const_iterator < _Tp > const_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;
typedef std :: reverse_iterator < iterator > reverse_iterator ;
typedef size_t size_type ;
typedef ptrdiff_t difference_type ;
typedef _Alloc allocator_type ;

protected :


typedef _List_node < _Tp > _Node ;

using _Base :: _M_impl ;
using _Base :: _M_put_node ;
using _Base :: _M_get_node ;
using _Base :: _M_get_Tp_allocator ;
using _Base :: _M_get_Node_allocator ;
#498
template < typename ... _Args >
_Node *
_M_create_node ( _Args && ... __args )
{
_Node * __p = this -> _M_get_node ( ) ;
try
{
_M_get_Node_allocator ( ) . construct ( __p ,
std :: forward < _Args > ( __args ) ... ) ;
}
catch ( ... )
{
_M_put_node ( __p ) ;
throw ;
}
return __p ;
}


public :





list ( )
: _Base ( ) { }





explicit
list ( const allocator_type & __a )
: _Base ( _Node_alloc_type ( __a ) ) { }
#542
explicit
list ( size_type __n )
: _Base ( )
{ _M_default_initialize ( __n ) ; }
#555
list ( size_type __n , const value_type & __value ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( _Node_alloc_type ( __a ) )
{ _M_fill_initialize ( __n , __value ) ; }
#582
list ( const list & __x )
: _Base ( __x . _M_get_Node_allocator ( ) )
{ _M_initialize_dispatch ( __x . begin ( ) , __x . end ( ) , __false_type ( ) ) ; }
#594
list ( list && __x ) noexcept
: _Base ( std :: move ( __x ) ) { }
#605
list ( initializer_list < value_type > __l ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( _Node_alloc_type ( __a ) )
{ _M_initialize_dispatch ( __l . begin ( ) , __l . end ( ) , __false_type ( ) ) ; }
#622
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
list ( _InputIterator __first , _InputIterator __last ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( _Node_alloc_type ( __a ) )
{ _M_initialize_dispatch ( __first , __last , __false_type ( ) ) ; }
#655
list &
operator = ( const list & __x ) ;
#666
list &
operator = ( list && __x )
{


this -> clear ( ) ;
this -> swap ( __x ) ;
return * this ;
}
#683
list &
operator = ( initializer_list < value_type > __l )
{
this -> assign ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}
#701
void
assign ( size_type __n , const value_type & __val )
{ _M_fill_assign ( __n , __val ) ; }
#718
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
void
assign ( _InputIterator __first , _InputIterator __last )
{ _M_assign_dispatch ( __first , __last , __false_type ( ) ) ; }
#742
void
assign ( initializer_list < value_type > __l )
{ this -> assign ( __l . begin ( ) , __l . end ( ) ) ; }



allocator_type
get_allocator ( ) const noexcept
{ return _Base :: get_allocator ( ) ; }
#757
iterator
begin ( ) noexcept
{ return iterator ( this -> _M_impl . _M_node . _M_next ) ; }
#766
const_iterator
begin ( ) const noexcept
{ return const_iterator ( this -> _M_impl . _M_node . _M_next ) ; }
#775
iterator
end ( ) noexcept
{ return iterator ( & this -> _M_impl . _M_node ) ; }
#784
const_iterator
end ( ) const noexcept
{ return const_iterator ( & this -> _M_impl . _M_node ) ; }
#793
reverse_iterator
rbegin ( ) noexcept
{ return reverse_iterator ( end ( ) ) ; }
#802
const_reverse_iterator
rbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }
#811
reverse_iterator
rend ( ) noexcept
{ return reverse_iterator ( begin ( ) ) ; }
#820
const_reverse_iterator
rend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }
#830
const_iterator
cbegin ( ) const noexcept
{ return const_iterator ( this -> _M_impl . _M_node . _M_next ) ; }
#839
const_iterator
cend ( ) const noexcept
{ return const_iterator ( & this -> _M_impl . _M_node ) ; }
#848
const_reverse_iterator
crbegin ( ) const noexcept
{ return const_reverse_iterator ( end ( ) ) ; }
#857
const_reverse_iterator
crend ( ) const noexcept
{ return const_reverse_iterator ( begin ( ) ) ; }
#867
bool
empty ( ) const noexcept
{ return this -> _M_impl . _M_node . _M_next == & this -> _M_impl . _M_node ; }


size_type
size ( ) const noexcept
{ return std :: distance ( begin ( ) , end ( ) ) ; }


size_type
max_size ( ) const noexcept
{ return _M_get_Node_allocator ( ) . max_size ( ) ; }
#891
void
resize ( size_type __new_size ) ;
#904
void
resize ( size_type __new_size , const value_type & __x ) ;
#926
reference
front ( )
{ return * begin ( ) ; }





const_reference
front ( ) const
{ return * begin ( ) ; }





reference
back ( )
{
iterator __tmp = end ( ) ;
-- __tmp ;
return * __tmp ;
}





const_reference
back ( ) const
{
const_iterator __tmp = end ( ) ;
-- __tmp ;
return * __tmp ;
}
#973
void
push_front ( const value_type & __x )
{ this -> _M_insert ( begin ( ) , __x ) ; }


void
push_front ( value_type && __x )
{ this -> _M_insert ( begin ( ) , std :: move ( __x ) ) ; }

template < typename ... _Args >
void
emplace_front ( _Args && ... __args )
{ this -> _M_insert ( begin ( ) , std :: forward < _Args > ( __args ) ... ) ; }
#1000
void
pop_front ( )
{ this -> _M_erase ( begin ( ) ) ; }
#1014
void
push_back ( const value_type & __x )
{ this -> _M_insert ( end ( ) , __x ) ; }


void
push_back ( value_type && __x )
{ this -> _M_insert ( end ( ) , std :: move ( __x ) ) ; }

template < typename ... _Args >
void
emplace_back ( _Args && ... __args )
{ this -> _M_insert ( end ( ) , std :: forward < _Args > ( __args ) ... ) ; }
#1040
void
pop_back ( )
{ this -> _M_erase ( iterator ( this -> _M_impl . _M_node . _M_prev ) ) ; }
#1057
template < typename ... _Args >
iterator
emplace ( iterator __position , _Args && ... __args ) ;
#1073
iterator
insert ( iterator __position , const value_type & __x ) ;
#1088
iterator
insert ( iterator __position , value_type && __x )
{ return emplace ( __position , std :: move ( __x ) ) ; }
#1105
void
insert ( iterator __p , initializer_list < value_type > __l )
{ this -> insert ( __p , __l . begin ( ) , __l . end ( ) ) ; }
#1122
void
insert ( iterator __position , size_type __n , const value_type & __x )
{
list __tmp ( __n , __x , get_allocator ( ) ) ;
splice ( __position , __tmp ) ;
}
#1143
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>



void
insert ( iterator __position , _InputIterator __first ,
_InputIterator __last )
{
list __tmp ( __first , __last , get_allocator ( ) ) ;
splice ( __position , __tmp ) ;
}
#1171
iterator
erase ( iterator __position ) ;
#1192
iterator
erase ( iterator __first , iterator __last )
{
while ( __first != __last )
__first = erase ( __first ) ;
return __last ;
}
#1209
void
swap ( list & __x )
{
__detail :: _List_node_base :: swap ( this -> _M_impl . _M_node ,
__x . _M_impl . _M_node ) ;



std :: __alloc_swap < typename _Base :: _Node_alloc_type > ::
_S_do_it ( _M_get_Node_allocator ( ) , __x . _M_get_Node_allocator ( ) ) ;
}
#1227
void
clear ( ) noexcept
{
_Base :: _M_clear ( ) ;
_Base :: _M_init ( ) ;
}
#1246
void

splice ( iterator __position , list && __x )



{
if ( ! __x . empty ( ) )
{
_M_check_equal_allocators ( __x ) ;

this -> _M_transfer ( __position , __x . begin ( ) , __x . end ( ) ) ;
}
}


void
splice ( iterator __position , list & __x )
{ splice ( __position , std :: move ( __x ) ) ; }
#1276
void

splice ( iterator __position , list && __x , iterator __i )



{
iterator __j = __i ;
++ __j ;
if ( __position == __i || __position == __j )
return ;

if ( this != & __x )
_M_check_equal_allocators ( __x ) ;

this -> _M_transfer ( __position , __i , __j ) ;
}


void
splice ( iterator __position , list & __x , iterator __i )
{ splice ( __position , std :: move ( __x ) , __i ) ; }
#1312
void

splice ( iterator __position , list && __x , iterator __first ,
iterator __last )




{
if ( __first != __last )
{
if ( this != & __x )
_M_check_equal_allocators ( __x ) ;

this -> _M_transfer ( __position , __first , __last ) ;
}
}


void
splice ( iterator __position , list & __x , iterator __first , iterator __last )
{ splice ( __position , std :: move ( __x ) , __first , __last ) ; }
#1347
void
remove ( const _Tp & __value ) ;
#1361
template < typename _Predicate >
void
remove_if ( _Predicate ) ;
#1375
void
unique ( ) ;
#1390
template < typename _BinaryPredicate >
void
unique ( _BinaryPredicate ) ;
#1404
void
merge ( list && __x ) ;

void
merge ( list & __x )
{ merge ( std :: move ( __x ) ) ; }
#1429
template < typename _StrictWeakOrdering >
void
merge ( list && __x , _StrictWeakOrdering __comp ) ;

template < typename _StrictWeakOrdering >
void
merge ( list & __x , _StrictWeakOrdering __comp )
{ merge ( std :: move ( __x ) , __comp ) ; }
#1448
void
reverse ( ) noexcept
{ this -> _M_impl . _M_node . _M_reverse ( ) ; }
#1458
void
sort ( ) ;
#1467
template < typename _StrictWeakOrdering >
void
sort ( _StrictWeakOrdering ) ;

protected :
#1478
template < typename _Integer >
void
_M_initialize_dispatch ( _Integer __n , _Integer __x , __true_type )
{ _M_fill_initialize ( static_cast < size_type > ( __n ) , __x ) ; }


template < typename _InputIterator >
void
_M_initialize_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type )
{
for ( ; __first != __last ; ++ __first )

emplace_back ( * __first ) ;



}



void
_M_fill_initialize ( size_type __n , const value_type & __x )
{
for ( ; __n ; -- __n )
push_back ( __x ) ;
}



void
_M_default_initialize ( size_type __n )
{
for ( ; __n ; -- __n )
emplace_back ( ) ;
}


void
_M_default_append ( size_type __n ) ;
#1526
template < typename _Integer >
void
_M_assign_dispatch ( _Integer __n , _Integer __val , __true_type )
{ _M_fill_assign ( __n , __val ) ; }


template < typename _InputIterator >
void
_M_assign_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type ) ;



void
_M_fill_assign ( size_type __n , const value_type & __val ) ;



void
_M_transfer ( iterator __position , iterator __first , iterator __last )
{ __position . _M_node -> _M_transfer ( __first . _M_node , __last . _M_node ) ; }
#1557
template < typename ... _Args >
void
_M_insert ( iterator __position , _Args && ... __args )
{
_Node * __tmp = _M_create_node ( std :: forward < _Args > ( __args ) ... ) ;
__tmp -> _M_hook ( __position . _M_node ) ;
}



void
_M_erase ( iterator __position )
{
__position . _M_node -> _M_unhook ( ) ;
_Node * __n = static_cast < _Node * > ( __position . _M_node ) ;

_M_get_Node_allocator ( ) . destroy ( __n ) ;



_M_put_node ( __n ) ;
}


void
_M_check_equal_allocators ( list & __x )
{
if ( std :: __alloc_neq < typename _Base :: _Node_alloc_type > ::
_S_do_it ( _M_get_Node_allocator ( ) , __x . _M_get_Node_allocator ( ) ) )
__throw_runtime_error ( ( "list::_M_check_equal_allocators" ) ) ;
}
} ;
#1600
template < typename _Tp , typename _Alloc >
inline bool
operator == ( const list < _Tp , _Alloc > & __x , const list < _Tp , _Alloc > & __y )
{
typedef typename list < _Tp , _Alloc > :: const_iterator const_iterator ;
const_iterator __end1 = __x . end ( ) ;
const_iterator __end2 = __y . end ( ) ;

const_iterator __i1 = __x . begin ( ) ;
const_iterator __i2 = __y . begin ( ) ;
while ( __i1 != __end1 && __i2 != __end2 && * __i1 == * __i2 )
{
++ __i1 ;
++ __i2 ;
}
return __i1 == __end1 && __i2 == __end2 ;
}
#1629
template < typename _Tp , typename _Alloc >
inline bool
operator < ( const list < _Tp , _Alloc > & __x , const list < _Tp , _Alloc > & __y )
{ return std :: lexicographical_compare ( __x . begin ( ) , __x . end ( ) ,
__y . begin ( ) , __y . end ( ) ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator != ( const list < _Tp , _Alloc > & __x , const list < _Tp , _Alloc > & __y )
{ return ! ( __x == __y ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator > ( const list < _Tp , _Alloc > & __x , const list < _Tp , _Alloc > & __y )
{ return __y < __x ; }


template < typename _Tp , typename _Alloc >
inline bool
operator <= ( const list < _Tp , _Alloc > & __x , const list < _Tp , _Alloc > & __y )
{ return ! ( __y < __x ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator >= ( const list < _Tp , _Alloc > & __x , const list < _Tp , _Alloc > & __y )
{ return ! ( __x < __y ) ; }


template < typename _Tp , typename _Alloc >
inline void
swap ( list < _Tp , _Alloc > & __x , list < _Tp , _Alloc > & __y )
{ __x . swap ( __y ) ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/list.tcc"
#59
namespace std
{


template < typename _Tp , typename _Alloc >
void
_List_base < _Tp , _Alloc > ::
_M_clear ( )
{
typedef _List_node < _Tp > _Node ;
_Node * __cur = static_cast < _Node * > ( _M_impl . _M_node . _M_next ) ;
while ( __cur != & _M_impl . _M_node )
{
_Node * __tmp = __cur ;
__cur = static_cast < _Node * > ( __cur -> _M_next ) ;

_M_get_Node_allocator ( ) . destroy ( __tmp ) ;



_M_put_node ( __tmp ) ;
}
}


template < typename _Tp , typename _Alloc >
template < typename ... _Args >
typename list < _Tp , _Alloc > :: iterator
list < _Tp , _Alloc > ::
emplace ( iterator __position , _Args && ... __args )
{
_Node * __tmp = _M_create_node ( std :: forward < _Args > ( __args ) ... ) ;
__tmp -> _M_hook ( __position . _M_node ) ;
return iterator ( __tmp ) ;
}


template < typename _Tp , typename _Alloc >
typename list < _Tp , _Alloc > :: iterator
list < _Tp , _Alloc > ::
insert ( iterator __position , const value_type & __x )
{
_Node * __tmp = _M_create_node ( __x ) ;
__tmp -> _M_hook ( __position . _M_node ) ;
return iterator ( __tmp ) ;
}

template < typename _Tp , typename _Alloc >
typename list < _Tp , _Alloc > :: iterator
list < _Tp , _Alloc > ::
erase ( iterator __position )
{
iterator __ret = iterator ( __position . _M_node -> _M_next ) ;
_M_erase ( __position ) ;
return __ret ;
}


template < typename _Tp , typename _Alloc >
void
list < _Tp , _Alloc > ::
_M_default_append ( size_type __n )
{
size_type __i = 0 ;
try
{
for ( ; __i < __n ; ++ __i )
emplace_back ( ) ;
}
catch ( ... )
{
for ( ; __i ; -- __i )
pop_back ( ) ;
throw ;
}
}

template < typename _Tp , typename _Alloc >
void
list < _Tp , _Alloc > ::
resize ( size_type __new_size )
{
iterator __i = begin ( ) ;
size_type __len = 0 ;
for ( ; __i != end ( ) && __len < __new_size ; ++ __i , ++ __len )
;
if ( __len == __new_size )
erase ( __i , end ( ) ) ;
else
_M_default_append ( __new_size - __len ) ;
}

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 ) ;
}
#182
template < typename _Tp , typename _Alloc >
list < _Tp , _Alloc > &
list < _Tp , _Alloc > ::
operator = ( const list & __x )
{
if ( this != & __x )
{
iterator __first1 = begin ( ) ;
iterator __last1 = end ( ) ;
const_iterator __first2 = __x . begin ( ) ;
const_iterator __last2 = __x . end ( ) ;
for ( ; __first1 != __last1 && __first2 != __last2 ;
++ __first1 , ++ __first2 )
* __first1 = * __first2 ;
if ( __first2 == __last2 )
erase ( __first1 , __last1 ) ;
else
insert ( __last1 , __first2 , __last2 ) ;
}
return * this ;
}

template < typename _Tp , typename _Alloc >
void
list < _Tp , _Alloc > ::
_M_fill_assign ( size_type __n , const value_type & __val )
{
iterator __i = begin ( ) ;
for ( ; __i != end ( ) && __n > 0 ; ++ __i , -- __n )
* __i = __val ;
if ( __n > 0 )
insert ( end ( ) , __n , __val ) ;
else
erase ( __i , end ( ) ) ;
}

template < typename _Tp , typename _Alloc >
template < typename _InputIterator >
void
list < _Tp , _Alloc > ::
_M_assign_dispatch ( _InputIterator __first2 , _InputIterator __last2 ,
__false_type )
{
iterator __first1 = begin ( ) ;
iterator __last1 = end ( ) ;
for ( ; __first1 != __last1 && __first2 != __last2 ;
++ __first1 , ++ __first2 )
* __first1 = * __first2 ;
if ( __first2 == __last2 )
erase ( __first1 , __last1 ) ;
else
insert ( __last1 , __first2 , __last2 ) ;
}

template < typename _Tp , typename _Alloc >
void
list < _Tp , _Alloc > ::
remove ( const value_type & __value )
{
iterator __first = begin ( ) ;
iterator __last = end ( ) ;
iterator __extra = __last ;
while ( __first != __last )
{
iterator __next = __first ;
++ __next ;
if ( * __first == __value )
{



if ( std :: __addressof ( * __first ) != std :: __addressof ( __value ) )
_M_erase ( __first ) ;
else
__extra = __first ;
}
__first = __next ;
}
if ( __extra != __last )
_M_erase ( __extra ) ;
}

template < typename _Tp , typename _Alloc >
void
list < _Tp , _Alloc > ::
unique ( )
{
iterator __first = begin ( ) ;
iterator __last = end ( ) ;
if ( __first == __last )
return ;
iterator __next = __first ;
while ( ++ __next != __last )
{
if ( * __first == * __next )
_M_erase ( __next ) ;
else
__first = __next ;
__next = __first ;
}
}

template < typename _Tp , typename _Alloc >
void
list < _Tp , _Alloc > ::

merge ( list && __x )



{


if ( this != & __x )
{
_M_check_equal_allocators ( __x ) ;

iterator __first1 = begin ( ) ;
iterator __last1 = end ( ) ;
iterator __first2 = __x . begin ( ) ;
iterator __last2 = __x . end ( ) ;
while ( __first1 != __last1 && __first2 != __last2 )
if ( * __first2 < * __first1 )
{
iterator __next = __first2 ;
_M_transfer ( __first1 , __first2 , ++ __next ) ;
__first2 = __next ;
}
else
++ __first1 ;
if ( __first2 != __last2 )
_M_transfer ( __last1 , __first2 , __last2 ) ;
}
}

template < typename _Tp , typename _Alloc >
template < typename _StrictWeakOrdering >
void
list < _Tp , _Alloc > ::

merge ( list && __x , _StrictWeakOrdering __comp )



{


if ( this != & __x )
{
_M_check_equal_allocators ( __x ) ;

iterator __first1 = begin ( ) ;
iterator __last1 = end ( ) ;
iterator __first2 = __x . begin ( ) ;
iterator __last2 = __x . end ( ) ;
while ( __first1 != __last1 && __first2 != __last2 )
if ( __comp ( * __first2 , * __first1 ) )
{
iterator __next = __first2 ;
_M_transfer ( __first1 , __first2 , ++ __next ) ;
__first2 = __next ;
}
else
++ __first1 ;
if ( __first2 != __last2 )
_M_transfer ( __last1 , __first2 , __last2 ) ;
}
}

template < typename _Tp , typename _Alloc >
void
list < _Tp , _Alloc > ::
sort ( )
{

if ( this -> _M_impl . _M_node . _M_next != & this -> _M_impl . _M_node
&& this -> _M_impl . _M_node . _M_next -> _M_next != & this -> _M_impl . _M_node )
{
list __carry ;
list __tmp [ 64 ] ;
list * __fill = & __tmp [ 0 ] ;
list * __counter ;

do
{
__carry . splice ( __carry . begin ( ) , * this , begin ( ) ) ;

for ( __counter = & __tmp [ 0 ] ;
__counter != __fill && ! __counter -> empty ( ) ;
++ __counter )
{
__counter -> merge ( __carry ) ;
__carry . swap ( * __counter ) ;
}
__carry . swap ( * __counter ) ;
if ( __counter == __fill )
++ __fill ;
}
while ( ! empty ( ) ) ;

for ( __counter = & __tmp [ 1 ] ; __counter != __fill ; ++ __counter )
__counter -> merge ( * ( __counter - 1 ) ) ;
swap ( * ( __fill - 1 ) ) ;
}
}

template < typename _Tp , typename _Alloc >
template < typename _Predicate >
void
list < _Tp , _Alloc > ::
remove_if ( _Predicate __pred )
{
iterator __first = begin ( ) ;
iterator __last = end ( ) ;
while ( __first != __last )
{
iterator __next = __first ;
++ __next ;
if ( __pred ( * __first ) )
_M_erase ( __first ) ;
__first = __next ;
}
}

template < typename _Tp , typename _Alloc >
template < typename _BinaryPredicate >
void
list < _Tp , _Alloc > ::
unique ( _BinaryPredicate __binary_pred )
{
iterator __first = begin ( ) ;
iterator __last = end ( ) ;
if ( __first == __last )
return ;
iterator __next = __first ;
while ( ++ __next != __last )
{
if ( __binary_pred ( * __first , * __next ) )
_M_erase ( __next ) ;
else
__first = __next ;
__next = __first ;
}
}

template < typename _Tp , typename _Alloc >
template < typename _StrictWeakOrdering >
void
list < _Tp , _Alloc > ::
sort ( _StrictWeakOrdering __comp )
{

if ( this -> _M_impl . _M_node . _M_next != & this -> _M_impl . _M_node
&& this -> _M_impl . _M_node . _M_next -> _M_next != & this -> _M_impl . _M_node )
{
list __carry ;
list __tmp [ 64 ] ;
list * __fill = & __tmp [ 0 ] ;
list * __counter ;

do
{
__carry . splice ( __carry . begin ( ) , * this , begin ( ) ) ;

for ( __counter = & __tmp [ 0 ] ;
__counter != __fill && ! __counter -> empty ( ) ;
++ __counter )
{
__counter -> merge ( __carry , __comp ) ;
__carry . swap ( * __counter ) ;
}
__carry . swap ( * __counter ) ;
if ( __counter == __fill )
++ __fill ;
}
while ( ! empty ( ) ) ;

for ( __counter = & __tmp [ 1 ] ; __counter != __fill ; ++ __counter )
__counter -> merge ( * ( __counter - 1 ) , __comp ) ;
swap ( * ( __fill - 1 ) ) ;
}
}


}
#32 "./boost/regex/pending/object_cache.hpp"
namespace boost {

template < class Key , class Object >
class object_cache
{
public :
typedef std :: pair < :: boost :: shared_ptr < Object const > , Key const * > value_type ;
typedef std :: list < value_type > list_type ;
typedef typename list_type :: iterator list_iterator ;
typedef std :: map < Key , list_iterator > map_type ;
typedef typename map_type :: iterator map_iterator ;
typedef typename list_type :: size_type size_type ;
static boost :: shared_ptr < Object const > get ( const Key & k , size_type l_max_cache_size ) ;

private :
static boost :: shared_ptr < Object const > do_get ( const Key & k , size_type l_max_cache_size ) ;

struct data
{
list_type cont ;
map_type index ;
} ;



friend struct data ;
} ;

template < class Key , class Object >
boost :: shared_ptr < Object const > object_cache < Key , Object > :: get ( const Key & k , size_type l_max_cache_size )
#61

{

static boost :: static_mutex mut = { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } , } ;

boost :: static_mutex :: scoped_lock l ( mut ) ;
if ( l )
{
return do_get ( k , l_max_cache_size ) ;
}




:: boost :: throw_exception ( std :: runtime_error ( "Error in thread safety code: could not acquire a lock" ) ) ;
#82
}

template < class Key , class Object >
boost :: shared_ptr < Object const > object_cache < Key , Object > :: do_get ( const Key & k , size_type l_max_cache_size
#85
)
{
typedef typename object_cache < Key , Object > :: data object_data ;
typedef typename map_type :: size_type map_size_type ;
static object_data s_data ;




map_iterator mpos = s_data . index . find ( k ) ;
if ( mpos != s_data . index . end ( ) )
{




if ( -- ( s_data . cont . end ( ) ) != mpos -> second )
{

list_type temp ;
temp . splice ( temp . end ( ) , s_data . cont , mpos -> second ) ;

s_data . cont . splice ( s_data . cont . end ( ) , temp , temp . begin ( ) ) ;
( ( void ) 0 ) ;

mpos -> second = -- ( s_data . cont . end ( ) ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
}
return s_data . cont . back ( ) . first ;
}




boost :: shared_ptr < Object const > result ( new Object ( k ) ) ;



s_data . cont . push_back ( value_type ( result , static_cast < Key const * > ( 0 ) ) ) ;
s_data . index . insert ( std :: make_pair ( k , -- ( s_data . cont . end ( ) ) ) ) ;
s_data . cont . back ( ) . second = & ( s_data . index . find ( k ) -> first ) ;
map_size_type s = s_data . index . size ( ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
if ( s > l_max_cache_size )
{





list_iterator pos = s_data . cont . begin ( ) ;
list_iterator last = s_data . cont . end ( ) ;
while ( ( pos != last ) && ( s > l_max_cache_size ) )
{
if ( pos -> first . unique ( ) )
{
list_iterator condemmed ( pos ) ;
++ pos ;


( ( void ) 0 ) ;
s_data . index . erase ( * ( condemmed -> second ) ) ;
s_data . cont . erase ( condemmed ) ;
-- s ;
}
else
++ pos ;
}
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
}
return result ;
}

}
#63 "./boost/regex/v4/cpp_regex_traits.hpp"
namespace boost {




template < class charT >
class cpp_regex_traits ;

namespace re_detail {





template < class charT ,
class traits = :: std :: char_traits < charT > >
class parser_buf : public :: std :: basic_streambuf < charT , traits >
{
typedef :: std :: basic_streambuf < charT , traits > base_type ;
typedef typename base_type :: int_type int_type ;
typedef typename base_type :: char_type char_type ;
typedef typename base_type :: pos_type pos_type ;
typedef :: std :: streamsize streamsize ;
typedef typename base_type :: off_type off_type ;
public :
parser_buf ( ) : base_type ( ) { setbuf ( 0 , 0 ) ; }
const charT * getnext ( ) { return this -> gptr ( ) ; }
protected :
std :: basic_streambuf < charT , traits > * setbuf ( char_type * s , streamsize n ) ;
typename parser_buf < charT , traits > :: pos_type seekpos ( pos_type sp , :: std :: ios_base :: openmode which ) ;
typename parser_buf < charT , traits > :: pos_type seekoff ( off_type off , :: std :: ios_base :: seekdir way , :: std ::
#93
ios_base :: openmode which ) ;
private :
parser_buf & operator = ( const parser_buf & ) ;
parser_buf ( const parser_buf & ) ;
} ;

template < class charT , class traits >
std :: basic_streambuf < charT , traits > *
parser_buf < charT , traits > :: setbuf ( char_type * s , streamsize n )
{
this -> setg ( s , s , s + n ) ;
return this ;
}

template < class charT , class traits >
typename parser_buf < charT , traits > :: pos_type
parser_buf < charT , traits > :: seekoff ( off_type off , :: std :: ios_base :: seekdir way , :: std :: ios_base :: openmode
#109
which )
{
typedef typename boost :: int_t < sizeof ( way ) * 8 > :: least cast_type ;

if ( which & :: std :: ios_base :: out )
return pos_type ( off_type ( - 1 ) ) ;
std :: ptrdiff_t size = this -> egptr ( ) - this -> eback ( ) ;
std :: ptrdiff_t pos = this -> gptr ( ) - this -> eback ( ) ;
charT * g = this -> eback ( ) ;
switch ( static_cast < cast_type > ( way ) )
{
case :: std :: ios_base :: beg :
if ( ( off < 0 ) || ( off > size ) )
return pos_type ( off_type ( - 1 ) ) ;
else
this -> setg ( g , g + off , g + size ) ;
break ;
case :: std :: ios_base :: end :
if ( ( off < 0 ) || ( off > size ) )
return pos_type ( off_type ( - 1 ) ) ;
else
this -> setg ( g , g + size - off , g + size ) ;
break ;
case :: std :: ios_base :: cur :
{
std :: ptrdiff_t newpos = static_cast < std :: ptrdiff_t > ( pos + off ) ;
if ( ( newpos < 0 ) || ( newpos > size ) )
return pos_type ( off_type ( - 1 ) ) ;
else
this -> setg ( g , g + newpos , g + size ) ;
break ;
}
default : ;
}




return static_cast < pos_type > ( this -> gptr ( ) - this -> eback ( ) ) ;



}

template < class charT , class traits >
typename parser_buf < charT , traits > :: pos_type
parser_buf < charT , traits > :: seekpos ( pos_type sp , :: std :: ios_base :: openmode which )
{
if ( which & :: std :: ios_base :: out )
return pos_type ( off_type ( - 1 ) ) ;
off_type size = static_cast < off_type > ( this -> egptr ( ) - this -> eback ( ) ) ;
charT * g = this -> eback ( ) ;
if ( off_type ( sp ) <= size )
{
this -> setg ( g , g + off_type ( sp ) , g + size ) ;
}
return pos_type ( off_type ( - 1 ) ) ;
}





template < class charT >
struct cpp_regex_traits_base
{
cpp_regex_traits_base ( const std :: locale & l )
{ imbue ( l ) ; }
std :: locale imbue ( const std :: locale & l ) ;

std :: locale m_locale ;
std :: ctype < charT > const * m_pctype ;

std :: messages < charT > const * m_pmessages ;

std :: collate < charT > const * m_pcollate ;

bool operator < ( const cpp_regex_traits_base & b ) const
{
if ( m_pctype == b . m_pctype )
{

if ( m_pmessages == b . m_pmessages )
{
return m_pcollate < b . m_pcollate ;
}
return m_pmessages < b . m_pmessages ;



}
return m_pctype < b . m_pctype ;
}
bool operator == ( const cpp_regex_traits_base & b ) const
{
return ( m_pctype == b . m_pctype )

&& ( m_pmessages == b . m_pmessages )

&& ( m_pcollate == b . m_pcollate ) ;
}
} ;

template < class charT >
std :: locale cpp_regex_traits_base < charT > :: imbue ( const std :: locale & l )
{
std :: locale result ( m_locale ) ;
m_locale = l ;
m_pctype = & std :: use_facet < std :: ctype < charT > > ( l ) ;

m_pmessages = std :: has_facet < std :: messages < charT > > ( l ) ? & std :: use_facet < std :: messages < charT > > ( l
#219
) : 0 ;

m_pcollate = & std :: use_facet < std :: collate < charT > > ( l ) ;
return result ;
}





template < class charT >
class cpp_regex_traits_char_layer : public cpp_regex_traits_base < charT >
{
typedef std :: basic_string < charT > string_type ;
typedef std :: map < charT , regex_constants :: syntax_type > map_type ;
typedef typename map_type :: const_iterator map_iterator_type ;
public :
cpp_regex_traits_char_layer ( const std :: locale & l )
: cpp_regex_traits_base < charT > ( l )
{
init ( ) ;
}
cpp_regex_traits_char_layer ( const cpp_regex_traits_base < charT > & b )
: cpp_regex_traits_base < charT > ( b )
{
init ( ) ;
}
void init ( ) ;

regex_constants :: syntax_type syntax_type ( charT c ) const
{
map_iterator_type i = m_char_map . find ( c ) ;
return ( ( i == m_char_map . end ( ) ) ? 0 : i -> second ) ;
}
regex_constants :: escape_syntax_type escape_syntax_type ( charT c ) const
{
map_iterator_type i = m_char_map . find ( c ) ;
if ( i == m_char_map . end ( ) )
{
if ( this -> m_pctype -> is ( std :: ctype_base :: lower , c ) ) return regex_constants :: escape_type_class ;
if ( this -> m_pctype -> is ( std :: ctype_base :: upper , c ) ) return regex_constants :: escape_type_not_class ;
return 0 ;
}
return i -> second ;
}

private :
string_type get_default_message ( regex_constants :: syntax_type ) ;

map_type m_char_map ;
} ;

template < class charT >
void cpp_regex_traits_char_layer < charT > :: init ( )
{




typename std :: messages < charT > :: catalog cat = static_cast < std :: messages < char > :: catalog > ( - 1 ) ;



std :: string cat_name ( cpp_regex_traits < charT > :: get_catalog_name ( ) ) ;
if ( cat_name . size ( ) && ( this -> m_pmessages != 0 ) )
{
cat = this -> m_pmessages -> open (
cat_name ,
this -> m_locale ) ;
if ( ( int ) cat < 0 )
{
std :: string m ( "Unable to open message catalog: " ) ;
std :: runtime_error err ( m + cat_name ) ;
boost :: re_detail :: raise_runtime_error ( err ) ;
}
}



if ( ( int ) cat >= 0 )
{

try {

for ( regex_constants :: syntax_type i = 1 ; i < regex_constants :: syntax_max ; ++ i )
{
string_type mss = this -> m_pmessages -> get ( cat , 0 , i , get_default_message ( i ) ) ;
for ( typename string_type :: size_type j = 0 ; j < mss . size ( ) ; ++ j )
{
m_char_map [ mss [ j ] ] = i ;
}
}
this -> m_pmessages -> close ( cat ) ;

}
catch ( ... )
{
if ( this -> m_pmessages )
this -> m_pmessages -> close ( cat ) ;
throw ;
}

}
else
{

for ( regex_constants :: syntax_type i = 1 ; i < regex_constants :: syntax_max ; ++ i )
{
const char * ptr = get_default_syntax ( i ) ;
while ( ptr && * ptr )
{
m_char_map [ this -> m_pctype -> widen ( * ptr ) ] = i ;
++ ptr ;
}
}

}

}

template < class charT >
typename cpp_regex_traits_char_layer < charT > :: string_type
cpp_regex_traits_char_layer < charT > :: get_default_message ( regex_constants :: syntax_type i )
{
const char * ptr = get_default_syntax ( i ) ;
string_type result ;
while ( ptr && * ptr )
{
result . append ( 1 , this -> m_pctype -> widen ( * ptr ) ) ;
++ ptr ;
}
return result ;
}




template < >
class cpp_regex_traits_char_layer < char > : public cpp_regex_traits_base < char >
{
typedef std :: string string_type ;
public :
cpp_regex_traits_char_layer ( const std :: locale & l )
: cpp_regex_traits_base < char > ( l )
{
init ( ) ;
}
cpp_regex_traits_char_layer ( const cpp_regex_traits_base < char > & l )
: cpp_regex_traits_base < char > ( l )
{
init ( ) ;
}

regex_constants :: syntax_type syntax_type ( char c ) const
{
return m_char_map [ static_cast < unsigned char > ( c ) ] ;
}
regex_constants :: escape_syntax_type escape_syntax_type ( char c ) const
{
return m_char_map [ static_cast < unsigned char > ( c ) ] ;
}

private :
regex_constants :: syntax_type m_char_map [ 1u << 8 ] ;
void init ( ) ;
} ;
#413
template < class charT >
class cpp_regex_traits_implementation : public cpp_regex_traits_char_layer < charT >
{
public :
typedef typename cpp_regex_traits < charT > :: char_class_type char_class_type ;
typedef typename std :: ctype < charT > :: mask native_mask_type ;

static const char_class_type mask_blank = 1u << 24 ;
static const char_class_type mask_word = 1u << 25 ;
static const char_class_type mask_unicode = 1u << 26 ;
static const char_class_type mask_horizontal = 1u << 27 ;
static const char_class_type mask_vertical = 1u << 28 ;


typedef std :: basic_string < charT > string_type ;
typedef charT char_type ;

cpp_regex_traits_implementation ( const std :: locale & l )
: cpp_regex_traits_char_layer < charT > ( l )
{
init ( ) ;
}
cpp_regex_traits_implementation ( const cpp_regex_traits_base < charT > & l )
: cpp_regex_traits_char_layer < charT > ( l )
{
init ( ) ;
}
std :: string error_string ( regex_constants :: error_type n ) const
{
if ( ! m_error_strings . empty ( ) )
{
std :: map < int , std :: string > :: const_iterator p = m_error_strings . find ( n ) ;
return ( p == m_error_strings . end ( ) ) ? std :: string ( get_default_error_string ( n ) ) : p -> second ;
}
return get_default_error_string ( n ) ;
}
char_class_type lookup_classname ( const charT * p1 , const charT * p2 ) const
{
char_class_type result = lookup_classname_imp ( p1 , p2 ) ;
if ( result == 0 )
{
string_type temp ( p1 , p2 ) ;
this -> m_pctype -> tolower ( & * temp . begin ( ) , & * temp . begin ( ) + temp . size ( ) ) ;
result = lookup_classname_imp ( & * temp . begin ( ) , & * temp . begin ( ) + temp . size ( ) ) ;
}
return result ;
}
string_type lookup_collatename ( const charT * p1 , const charT * p2 ) const ;
string_type transform_primary ( const charT * p1 , const charT * p2 ) const ;
string_type transform ( const charT * p1 , const charT * p2 ) const ;
private :
std :: map < int , std :: string > m_error_strings ;
std :: map < string_type , char_class_type > m_custom_class_names ;
std :: map < string_type , string_type > m_custom_collate_names ;
unsigned m_collate_type ;
charT m_collate_delim ;



char_class_type lookup_classname_imp ( const charT * p1 , const charT * p2 ) const ;
void init ( ) ;




} ;




template < class charT >
typename cpp_regex_traits_implementation < charT > :: char_class_type const cpp_regex_traits_implementation < charT > ::
#484
mask_blank ;
template < class charT >
typename cpp_regex_traits_implementation < charT > :: char_class_type const cpp_regex_traits_implementation < charT > ::
#486
mask_word ;
template < class charT >
typename cpp_regex_traits_implementation < charT > :: char_class_type const cpp_regex_traits_implementation < charT > ::
#488
mask_unicode ;
template < class charT >
typename cpp_regex_traits_implementation < charT > :: char_class_type const cpp_regex_traits_implementation < charT > ::
#490
mask_vertical ;
template < class charT >
typename cpp_regex_traits_implementation < charT > :: char_class_type const cpp_regex_traits_implementation < charT > ::
#492
mask_horizontal ;




template < class charT >
typename cpp_regex_traits_implementation < charT > :: string_type
cpp_regex_traits_implementation < charT > :: transform_primary ( const charT * p1 , const charT * p2 ) const
{
#509
( ( void ) 0 ) ;

string_type result ;
#518
try {





switch ( m_collate_type )
{
case sort_C :
case sort_unknown :

{
result . assign ( p1 , p2 ) ;
this -> m_pctype -> tolower ( & * result . begin ( ) , & * result . begin ( ) + result . size ( ) ) ;
result = this -> m_pcollate -> transform ( & * result . begin ( ) , & * result . begin ( ) + result . size ( ) ) ;
break ;
}
case sort_fixed :
{

result . assign ( this -> m_pcollate -> transform ( p1 , p2 ) ) ;
result . erase ( this -> m_collate_delim ) ;
break ;
}
case sort_delim :

result . assign ( this -> m_pcollate -> transform ( p1 , p2 ) ) ;
std :: size_t i ;
for ( i = 0 ; i < result . size ( ) ; ++ i )
{
if ( result [ i ] == m_collate_delim )
break ;
}
result . erase ( i ) ;
break ;
}

} catch ( ... ) { }

while ( result . size ( ) && ( charT ( 0 ) == * result . rbegin ( ) ) )
result . erase ( result . size ( ) - 1 ) ;
if ( result . empty ( ) )
{

result = string_type ( 1 , charT ( 0 ) ) ;
}
return result ;
}

template < class charT >
typename cpp_regex_traits_implementation < charT > :: string_type
cpp_regex_traits_implementation < charT > :: transform ( const charT * p1 , const charT * p2 ) const
{
#579
( ( void ) 0 ) ;





string_type result ;

try {

result = this -> m_pcollate -> transform ( p1 , p2 ) ;
#601
while ( result . size ( ) && ( charT ( 0 ) == * result . rbegin ( ) ) )
result . erase ( result . size ( ) - 1 ) ;

( ( void ) 0 ) ;

}
catch ( ... )
{
}

return result ;
}


template < class charT >
typename cpp_regex_traits_implementation < charT > :: string_type
cpp_regex_traits_implementation < charT > :: lookup_collatename ( const charT * p1 , const charT * p2 ) const
{
typedef typename std :: map < string_type , string_type > :: const_iterator iter_type ;
if ( m_custom_collate_names . size ( ) )
{
iter_type pos = m_custom_collate_names . find ( string_type ( p1 , p2 ) ) ;
if ( pos != m_custom_collate_names . end ( ) )
return pos -> second ;
}



std :: string name ( p1 , p2 ) ;
#636
name = lookup_default_collate_name ( name ) ;



if ( name . size ( ) )
return string_type ( name . begin ( ) , name . end ( ) ) ;
#654
if ( p2 - p1 == 1 )
return string_type ( 1 , * p1 ) ;
return string_type ( ) ;
}

template < class charT >
void cpp_regex_traits_implementation < charT > :: init ( )
{


typename std :: messages < charT > :: catalog cat = static_cast < std :: messages < char > :: catalog > ( - 1 ) ;



std :: string cat_name ( cpp_regex_traits < charT > :: get_catalog_name ( ) ) ;
if ( cat_name . size ( ) && ( this -> m_pmessages != 0 ) )
{
cat = this -> m_pmessages -> open (
cat_name ,
this -> m_locale ) ;
if ( ( int ) cat < 0 )
{
std :: string m ( "Unable to open message catalog: " ) ;
std :: runtime_error err ( m + cat_name ) ;
boost :: re_detail :: raise_runtime_error ( err ) ;
}
}



if ( ( int ) cat >= 0 )
{



for ( boost :: regex_constants :: error_type i = static_cast < boost :: regex_constants :: error_type > ( 0 ) ;
i <= boost :: regex_constants :: error_unknown ;
i = static_cast < boost :: regex_constants :: error_type > ( i + 1 ) )
{
const char * p = get_default_error_string ( i ) ;
string_type default_message ;
while ( * p )
{
default_message . append ( 1 , this -> m_pctype -> widen ( * p ) ) ;
++ p ;
}
string_type s = this -> m_pmessages -> get ( cat , 0 , i + 200 , default_message ) ;
std :: string result ;
for ( std :: string :: size_type j = 0 ; j < s . size ( ) ; ++ j )
{
result . append ( 1 , this -> m_pctype -> narrow ( s [ j ] , 0 ) ) ;
}
m_error_strings [ i ] = result ;
}




static const char_class_type masks [ 16 ] =
{
std :: ctype < charT > :: alnum ,
std :: ctype < charT > :: alpha ,
std :: ctype < charT > :: cntrl ,
std :: ctype < charT > :: digit ,
std :: ctype < charT > :: graph ,
cpp_regex_traits_implementation < charT > :: mask_horizontal ,
std :: ctype < charT > :: lower ,
std :: ctype < charT > :: print ,
std :: ctype < charT > :: punct ,
std :: ctype < charT > :: space ,
std :: ctype < charT > :: upper ,
cpp_regex_traits_implementation < charT > :: mask_vertical ,
std :: ctype < charT > :: xdigit ,
cpp_regex_traits_implementation < charT > :: mask_blank ,
cpp_regex_traits_implementation < charT > :: mask_word ,
cpp_regex_traits_implementation < charT > :: mask_unicode ,
} ;
#752
static const string_type null_string ;
for ( unsigned int j = 0 ; j <= 13 ; ++ j )
{
string_type s ( this -> m_pmessages -> get ( cat , 0 , j + 300 , null_string ) ) ;
if ( s . size ( ) )
this -> m_custom_class_names [ s ] = masks [ j ] ;
}
}




m_collate_type = re_detail :: find_sort_syntax ( this , & m_collate_delim ) ;
}

template < class charT >
typename cpp_regex_traits_implementation < charT > :: char_class_type
cpp_regex_traits_implementation < charT > :: lookup_classname_imp ( const charT * p1 , const charT * p2 ) const
{

static const char_class_type masks [ 22 ] =
{
0 ,
std :: ctype < char > :: alnum ,
std :: ctype < char > :: alpha ,
cpp_regex_traits_implementation < charT > :: mask_blank ,
std :: ctype < char > :: cntrl ,
std :: ctype < char > :: digit ,
std :: ctype < char > :: digit ,
std :: ctype < char > :: graph ,
cpp_regex_traits_implementation < charT > :: mask_horizontal ,
std :: ctype < char > :: lower ,
std :: ctype < char > :: lower ,
std :: ctype < char > :: print ,
std :: ctype < char > :: punct ,
std :: ctype < char > :: space ,
std :: ctype < char > :: space ,
std :: ctype < char > :: upper ,
cpp_regex_traits_implementation < charT > :: mask_unicode ,
std :: ctype < char > :: upper ,
cpp_regex_traits_implementation < charT > :: mask_vertical ,
std :: ctype < char > :: alnum | cpp_regex_traits_implementation < charT > :: mask_word ,
std :: ctype < char > :: alnum | cpp_regex_traits_implementation < charT > :: mask_word ,
std :: ctype < char > :: xdigit ,
} ;
#824
if ( m_custom_class_names . size ( ) )
{
typedef typename std :: map < std :: basic_string < charT > , char_class_type > :: const_iterator map_iter ;
map_iter pos = m_custom_class_names . find ( string_type ( p1 , p2 ) ) ;
if ( pos != m_custom_class_names . end ( ) )
return pos -> second ;
}
std :: size_t state_id = 1 + re_detail :: get_default_class_id ( p1 , p2 ) ;
( ( void ) 0 ) ;
return masks [ state_id ] ;
}
#859
template < class charT >
inline boost :: shared_ptr < const cpp_regex_traits_implementation < charT > > create_cpp_regex_traits ( const std :: locale
#860
& l )
{
cpp_regex_traits_base < charT > key ( l ) ;
return :: boost :: object_cache < cpp_regex_traits_base < charT > , cpp_regex_traits_implementation < charT > > :: get (
#863
key , 5 ) ;
}

}

template < class charT >
class cpp_regex_traits
{
private :
typedef std :: ctype < charT > ctype_type ;
public :
typedef charT char_type ;
typedef std :: size_t size_type ;
typedef std :: basic_string < char_type > string_type ;
typedef std :: locale locale_type ;
typedef boost :: uint_least32_t char_class_type ;

struct boost_extensions_tag { } ;

cpp_regex_traits ( )
: m_pimpl ( re_detail :: create_cpp_regex_traits < charT > ( std :: locale ( ) ) )
{ }
static size_type length ( const char_type * p )
{
return std :: char_traits < charT > :: length ( p ) ;
}
regex_constants :: syntax_type syntax_type ( charT c ) const
{
return m_pimpl -> syntax_type ( c ) ;
}
regex_constants :: escape_syntax_type escape_syntax_type ( charT c ) const
{
return m_pimpl -> escape_syntax_type ( c ) ;
}
charT translate ( charT c ) const
{
return c ;
}
charT translate_nocase ( charT c ) const
{
return m_pimpl -> m_pctype -> tolower ( c ) ;
}
charT translate ( charT c , bool icase ) const
{
return icase ? m_pimpl -> m_pctype -> tolower ( c ) : c ;
}
charT tolower ( charT c ) const
{
return m_pimpl -> m_pctype -> tolower ( c ) ;
}
charT toupper ( charT c ) const
{
return m_pimpl -> m_pctype -> toupper ( c ) ;
}
string_type transform ( const charT * p1 , const charT * p2 ) const
{
return m_pimpl -> transform ( p1 , p2 ) ;
}
string_type transform_primary ( const charT * p1 , const charT * p2 ) const
{
return m_pimpl -> transform_primary ( p1 , p2 ) ;
}
char_class_type lookup_classname ( const charT * p1 , const charT * p2 ) const
{
return m_pimpl -> lookup_classname ( p1 , p2 ) ;
}
string_type lookup_collatename ( const charT * p1 , const charT * p2 ) const
{
return m_pimpl -> lookup_collatename ( p1 , p2 ) ;
}
bool isctype ( charT c , char_class_type f ) const
{

typedef typename std :: ctype < charT > :: mask ctype_mask ;

static const ctype_mask mask_base =
static_cast < ctype_mask > (
std :: ctype < charT > :: alnum
| std :: ctype < charT > :: alpha
| std :: ctype < charT > :: cntrl
| std :: ctype < charT > :: digit
| std :: ctype < charT > :: graph
| std :: ctype < charT > :: lower
| std :: ctype < charT > :: print
| std :: ctype < charT > :: punct
| std :: ctype < charT > :: space
| std :: ctype < charT > :: upper
| std :: ctype < charT > :: xdigit ) ;

if ( ( f & mask_base )
&& ( m_pimpl -> m_pctype -> is (
static_cast < ctype_mask > ( f & mask_base ) , c ) ) )
return true ;
else if ( ( f & re_detail :: cpp_regex_traits_implementation < charT > :: mask_unicode ) && re_detail :: is_extended ( c
#956
) )
return true ;
else if ( ( f & re_detail :: cpp_regex_traits_implementation < charT > :: mask_word ) && ( c == '_' ) )
return true ;
else if ( ( f & re_detail :: cpp_regex_traits_implementation < charT > :: mask_blank )
&& m_pimpl -> m_pctype -> is ( std :: ctype < charT > :: space , c )
&& ! re_detail :: is_separator ( c ) )
return true ;
else if ( ( f & re_detail :: cpp_regex_traits_implementation < charT > :: mask_vertical )
&& ( :: boost :: re_detail :: is_separator ( c ) || ( c == '\v' ) ) )
return true ;
else if ( ( f & re_detail :: cpp_regex_traits_implementation < charT > :: mask_horizontal )
&& this -> isctype ( c , std :: ctype < charT > :: space ) && ! this -> isctype ( c , re_detail :: cpp_regex_traits_implementation
#968
< charT > :: mask_vertical ) )
return true ;
return false ;



}
int toi ( const charT * & p1 , const charT * p2 , int radix ) const ;
int value ( charT c , int radix ) const
{
const charT * pc = & c ;
return toi ( pc , pc + 1 , radix ) ;
}
locale_type imbue ( locale_type l )
{
std :: locale result ( getloc ( ) ) ;
m_pimpl = re_detail :: create_cpp_regex_traits < charT > ( l ) ;
return result ;
}
locale_type getloc ( ) const
{
return m_pimpl -> m_locale ;
}
std :: string error_string ( regex_constants :: error_type n ) const
{
return m_pimpl -> error_string ( n ) ;
}





static std :: string catalog_name ( const std :: string & name ) ;
static std :: string get_catalog_name ( ) ;

private :
boost :: shared_ptr < const re_detail :: cpp_regex_traits_implementation < charT > > m_pimpl ;



static std :: string & get_catalog_name_inst ( ) ;


static static_mutex & get_mutex_inst ( ) ;

} ;


template < class charT >
int cpp_regex_traits < charT > :: toi ( const charT * & first , const charT * last , int radix ) const
{
re_detail :: parser_buf < charT > sbuf ;
std :: basic_istream < charT > is ( & sbuf ) ;


last = std :: find ( first , last , std :: use_facet < std :: numpunct < charT > > ( is . getloc ( ) ) . thousands_sep (
#1023
) ) ;

sbuf . pubsetbuf ( const_cast < charT * > ( static_cast < const charT * > ( first ) ) , static_cast < std :: streamsize >
#1025
( last - first ) ) ;
is . clear ( ) ;
if ( std :: abs ( radix ) == 16 ) is >> std :: hex ;
else if ( std :: abs ( radix ) == 8 ) is >> std :: oct ;
else is >> std :: dec ;
int val ;
if ( is >> val )
{
first = first + ( ( last - first ) - sbuf . in_avail ( ) ) ;
return val ;
}
else
return - 1 ;
}

template < class charT >
std :: string cpp_regex_traits < charT > :: catalog_name ( const std :: string & name )
{

static_mutex :: scoped_lock lk ( get_mutex_inst ( ) ) ;

std :: string result ( get_catalog_name_inst ( ) ) ;
get_catalog_name_inst ( ) = name ;
return result ;
}

template < class charT >
std :: string & cpp_regex_traits < charT > :: get_catalog_name_inst ( )
{
static std :: string s_name ;
return s_name ;
}

template < class charT >
std :: string cpp_regex_traits < charT > :: get_catalog_name ( )
{

static_mutex :: scoped_lock lk ( get_mutex_inst ( ) ) ;

std :: string result ( get_catalog_name_inst ( ) ) ;
return result ;
}


template < class charT >
static_mutex & cpp_regex_traits < charT > :: get_mutex_inst ( )
{
static static_mutex s_mutex = { { { 0 , 0 , 0 , 0 , 0x4d58 } , { { { 0 } } } , 0 } , } ;
return s_mutex ;
}



}
#1 "./boost/regex/v4/c_regex_traits.hpp"
#48
namespace boost {

template < class charT >
struct c_regex_traits ;

template < >
struct c_regex_traits < char >
{
c_regex_traits ( ) { }
typedef char char_type ;
typedef std :: size_t size_type ;
typedef std :: string string_type ;
struct locale_type { } ;
typedef boost :: uint32_t char_class_type ;

static size_type length ( const char_type * p )
{
return ( std :: strlen ) ( p ) ;
}

char translate ( char c ) const
{
return c ;
}
char translate_nocase ( char c ) const
{
return static_cast < char > ( ( std :: tolower ) ( static_cast < unsigned char > ( c ) ) ) ;
}

static string_type transform ( const char * p1 , const char * p2 ) ;
static string_type transform_primary ( const char * p1 , const char * p2 ) ;

static char_class_type lookup_classname ( const char * p1 , const char * p2 ) ;
static string_type lookup_collatename ( const char * p1 , const char * p2 ) ;

static bool isctype ( char , char_class_type ) ;
static int value ( char , int ) ;

locale_type imbue ( locale_type l )
{ return l ; }
locale_type getloc ( ) const
{ return locale_type ( ) ; }

private :

c_regex_traits ( const c_regex_traits & ) ;
c_regex_traits & operator = ( const c_regex_traits & ) ;
} ;


template < >
struct c_regex_traits < wchar_t >
{
c_regex_traits ( ) { }
typedef wchar_t char_type ;
typedef std :: size_t size_type ;
typedef std :: wstring string_type ;
struct locale_type { } ;
typedef boost :: uint32_t char_class_type ;

static size_type length ( const char_type * p )
{
return ( std :: wcslen ) ( p ) ;
}

wchar_t translate ( wchar_t c ) const
{
return c ;
}
wchar_t translate_nocase ( wchar_t c ) const
{
return ( std :: towlower ) ( c ) ;
}

static string_type transform ( const wchar_t * p1 , const wchar_t * p2 ) ;
static string_type transform_primary ( const wchar_t * p1 , const wchar_t * p2 ) ;

static char_class_type lookup_classname ( const wchar_t * p1 , const wchar_t * p2 ) ;
static string_type lookup_collatename ( const wchar_t * p1 , const wchar_t * p2 ) ;

static bool isctype ( wchar_t , char_class_type ) ;
static int value ( wchar_t , int ) ;

locale_type imbue ( locale_type l )
{ return l ; }
locale_type getloc ( ) const
{ return locale_type ( ) ; }

private :

c_regex_traits ( const c_regex_traits & ) ;
c_regex_traits & operator = ( const c_regex_traits & ) ;
} ;
#195
}
#1 "./boost/mpl/has_xxx.hpp"
#1 "./boost/mpl/bool.hpp"
#1 "./boost/mpl/integral_c_tag.hpp"
#1 "./boost/mpl/aux_/config/static_constant.hpp"
#21 "./boost/mpl/integral_c_tag.hpp"
namespace mpl_ {
struct integral_c_tag { static const int value = 0 ; } ;
}
namespace boost { namespace mpl { using :: mpl_ :: integral_c_tag ; } }
#21 "./boost/mpl/bool.hpp"
namespace mpl_ {

template < bool C_ > struct bool_
{
static const bool value = C_ ;
typedef integral_c_tag tag ;
typedef bool_ type ;
typedef bool value_type ;
operator bool ( ) const { return this -> value ; }
} ;


template < bool C_ >
bool const bool_ < C_ > :: value ;


}
#1 "./boost/mpl/aux_/na_spec.hpp"
#1 "./boost/mpl/lambda_fwd.hpp"
#1 "./boost/mpl/void_fwd.hpp"
#19
namespace mpl_ {

struct void_ ;

}
namespace boost { namespace mpl { using :: mpl_ :: void_ ; } }
#1 "./boost/mpl/aux_/na.hpp"
#1 "./boost/mpl/aux_/na_fwd.hpp"
#19
namespace mpl_ {


struct na
{
typedef na type ;
enum { value = 0 } ;
} ;

}
namespace boost { namespace mpl { using :: mpl_ :: na ; } }
#1 "./boost/mpl/aux_/config/ctps.hpp"
#22 "./boost/mpl/aux_/na.hpp"
namespace boost { namespace mpl {

template < typename T >
struct is_na
: false_
{



} ;

template < >
struct is_na < na >
: true_
{



} ;

template < typename T >
struct is_not_na
: true_
{



} ;

template < >
struct is_not_na < na >
: false_
{



} ;


template < typename T , typename U > struct if_na
{
typedef T type ;
} ;

template < typename U > struct if_na < na , U >
{
typedef U type ;
} ;
#93
} }
#1 "./boost/mpl/aux_/config/lambda.hpp"
#1 "./boost/mpl/aux_/config/ttp.hpp"
#1 "./boost/mpl/int.hpp"
#1 "./boost/mpl/int_fwd.hpp"
#1 "./boost/mpl/aux_/nttp_decl.hpp"
#1 "./boost/mpl/aux_/config/nttp.hpp"
#20 "./boost/mpl/int_fwd.hpp"
namespace mpl_ {

template < int N > struct int_ ;

}
namespace boost { namespace mpl { using :: mpl_ :: int_ ; } }
#1 "./boost/mpl/aux_/integral_wrapper.hpp"
#1 "./boost/mpl/aux_/static_cast.hpp"
#1 "./boost/preprocessor/cat.hpp"
#1 "./boost/preprocessor/config/config.hpp"
#40 "./boost/mpl/aux_/integral_wrapper.hpp"
namespace mpl_ {

template < int N >
struct int_
{
static const int value = N ;





typedef int_ type ;

typedef int value_type ;
typedef integral_c_tag tag ;
#72
typedef mpl_ :: int_ < static_cast < int > ( ( value + 1 ) ) > next ;
typedef mpl_ :: int_ < static_cast < int > ( ( value - 1 ) ) > prior ;
#80
operator int ( ) const { return static_cast < int > ( this -> value ) ; }
} ;


template < int N >
int const mpl_ :: int_ < N > :: value ;


}
#1 "./boost/mpl/aux_/lambda_arity_param.hpp"
#1 "./boost/mpl/aux_/template_arity_fwd.hpp"
#17
namespace boost { namespace mpl { namespace aux {

template < typename F > struct template_arity ;

} } }
#27 "./boost/mpl/lambda_fwd.hpp"
namespace boost { namespace mpl {

template <
typename T = na
, typename Tag = void_



>
struct lambda ;

} }
#1 "./boost/mpl/aux_/arity.hpp"
#1 "./boost/mpl/aux_/config/dtp.hpp"
#1 "./boost/mpl/aux_/preprocessor/params.hpp"
#1 "./boost/mpl/aux_/config/preprocessor.hpp"
#1 "./boost/preprocessor/comma_if.hpp"
#1 "./boost/preprocessor/punctuation/comma_if.hpp"
#1 "./boost/preprocessor/control/if.hpp"
#1 "./boost/preprocessor/control/iif.hpp"
#1 "./boost/preprocessor/logical/bool.hpp"
#1 "./boost/preprocessor/facilities/empty.hpp"
#1 "./boost/preprocessor/punctuation/comma.hpp"
#1 "./boost/preprocessor/repeat.hpp"
#1 "./boost/preprocessor/repetition/repeat.hpp"
#1 "./boost/preprocessor/debug/error.hpp"
#1 "./boost/preprocessor/detail/auto_rec.hpp"
#1 "./boost/preprocessor/tuple/eat.hpp"
#1 "./boost/preprocessor/inc.hpp"
#1 "./boost/preprocessor/arithmetic/inc.hpp"
#1 "./boost/mpl/aux_/preprocessor/enum.hpp"
#1 "./boost/mpl/aux_/preprocessor/def_params_tail.hpp"
#1 "./boost/mpl/limits/arity.hpp"
#1 "./boost/preprocessor/logical/and.hpp"
#1 "./boost/preprocessor/logical/bitand.hpp"
#1 "./boost/preprocessor/identity.hpp"
#1 "./boost/preprocessor/facilities/identity.hpp"
#1 "./boost/preprocessor/empty.hpp"
#1 "./boost/preprocessor/arithmetic/add.hpp"
#1 "./boost/preprocessor/arithmetic/dec.hpp"
#1 "./boost/preprocessor/control/while.hpp"
#1 "./boost/preprocessor/detail/auto_rec.hpp"
#1 "./boost/preprocessor/list/fold_left.hpp"
#1 "./boost/preprocessor/control/while.hpp"
#1 "./boost/preprocessor/detail/auto_rec.hpp"
#1 "./boost/preprocessor/list/detail/fold_left.hpp"
#1 "./boost/preprocessor/control/expr_iif.hpp"
#1 "./boost/preprocessor/list/adt.hpp"
#1 "./boost/preprocessor/detail/is_binary.hpp"
#1 "./boost/preprocessor/detail/check.hpp"
#1 "./boost/preprocessor/logical/compl.hpp"
#1 "./boost/preprocessor/list/fold_right.hpp"
#1 "./boost/preprocessor/control/while.hpp"
#1 "./boost/preprocessor/detail/auto_rec.hpp"
#1 "./boost/preprocessor/list/detail/fold_right.hpp"
#1 "./boost/preprocessor/list/reverse.hpp"
#1 "./boost/preprocessor/control/detail/while.hpp"
#1 "./boost/preprocessor/tuple/elem.hpp"
#1 "./boost/preprocessor/facilities/overload.hpp"
#1 "./boost/preprocessor/variadic/size.hpp"
#1 "./boost/preprocessor/tuple/rem.hpp"
#1 "./boost/preprocessor/variadic/elem.hpp"
#1 "./boost/preprocessor/arithmetic/sub.hpp"
#1 "./boost/mpl/aux_/config/eti.hpp"
#1 "./boost/mpl/aux_/config/overload_resolution.hpp"
#1 "./boost/mpl/aux_/type_wrapper.hpp"
#20
namespace boost { namespace mpl { namespace aux {

template < typename T > struct type_wrapper
{
typedef T type ;
} ;
#32
template < typename T > struct wrapped_type ;

template < typename T > struct wrapped_type < type_wrapper < T > >
{
typedef T type ;
} ;
#45
} } }
#1 "./boost/mpl/aux_/yes_no.hpp"
#1 "./boost/mpl/aux_/config/arrays.hpp"
#23 "./boost/mpl/aux_/yes_no.hpp"
namespace boost { namespace mpl { namespace aux {

typedef char ( & no_tag ) [ 1 ] ;
typedef char ( & yes_tag ) [ 2 ] ;

template < bool C_ > struct yes_no_tag
{
typedef no_tag type ;
} ;

template < > struct yes_no_tag < true >
{
typedef yes_tag type ;
} ;


template < long n > struct weighted_tag
{

typedef char ( & type ) [ n ] ;




} ;
#56
} } }
#1 "./boost/mpl/aux_/config/has_xxx.hpp"
#1 "./boost/mpl/aux_/config/msvc_typename.hpp"
#1 "./boost/preprocessor/array/elem.hpp"
#1 "./boost/preprocessor/array/data.hpp"
#1 "./boost/preprocessor/array/size.hpp"
#1 "./boost/preprocessor/repetition/enum_params.hpp"
#1 "./boost/preprocessor/repetition/enum_trailing_params.hpp"
#70 "./boost/regex/v4/regex_traits.hpp"
namespace boost {

template < class charT , class implementationT >
struct regex_traits : public implementationT
{
regex_traits ( ) : implementationT ( ) { }
} ;
#85
namespace re_detail {

template < typename T , typename fallback_ = boost :: mpl :: bool_ < false > > struct has_boost_extensions_tag { struct gcc_3_2_wknd
#87
{ template < typename U > static boost :: mpl :: aux :: yes_tag test ( boost :: mpl :: aux :: type_wrapper < U > const volatile
#87
* , boost :: mpl :: aux :: type_wrapper < typename U :: boost_extensions_tag > * = 0 ) ; static boost :: mpl :: aux :: no_tag
#87
test ( ... ) ; } ; typedef boost :: mpl :: aux :: type_wrapper < T > t_ ; static const bool value = sizeof ( gcc_3_2_wknd
#87
:: test ( static_cast < t_ * > ( 0 ) ) ) == sizeof ( boost :: mpl :: aux :: yes_tag ) ; typedef boost :: mpl :: bool_ < value
#87
> type ; } ;
#96
template < class BaseT >
struct default_wrapper : public BaseT
{
typedef typename BaseT :: char_type char_type ;
std :: string error_string ( :: boost :: regex_constants :: error_type e ) const
{
return :: boost :: re_detail :: get_default_error_string ( e ) ;
}
:: boost :: regex_constants :: syntax_type syntax_type ( char_type c ) const
{
return ( ( c & 0x7f ) == c ) ? get_default_syntax_type ( static_cast < char > ( c ) ) : :: boost :: regex_constants :: syntax_char
#106
;
}
:: boost :: regex_constants :: escape_syntax_type escape_syntax_type ( char_type c ) const
{
return ( ( c & 0x7f ) == c ) ? get_default_escape_syntax_type ( static_cast < char > ( c ) ) : :: boost :: regex_constants
#110
:: escape_type_identity ;
}
int toi ( const char_type * & p1 , const char_type * p2 , int radix ) const
{
return :: boost :: re_detail :: global_toi ( p1 , p2 , radix , * this ) ;
}
char_type translate ( char_type c , bool icase ) const
{
return ( icase ? this -> translate_nocase ( c ) : this -> translate ( c ) ) ;
}
char_type translate ( char_type c ) const
{
return BaseT :: translate ( c ) ;
}
char_type tolower ( char_type c ) const
{
return :: boost :: re_detail :: global_lower ( c ) ;
}
char_type toupper ( char_type c ) const
{
return :: boost :: re_detail :: global_upper ( c ) ;
}
} ;

template < class BaseT , bool has_extensions >
struct compute_wrapper_base
{
typedef BaseT type ;
} ;

template < class BaseT >
struct compute_wrapper_base < BaseT , false >
{
typedef default_wrapper < BaseT > type ;
} ;
#160
}

template < class BaseT >
struct regex_traits_wrapper
: public :: boost :: re_detail :: compute_wrapper_base <
BaseT ,
:: boost :: re_detail :: has_boost_extensions_tag < BaseT > :: value
> :: type
{
regex_traits_wrapper ( ) { }
private :
regex_traits_wrapper ( const regex_traits_wrapper & ) ;
regex_traits_wrapper & operator = ( const regex_traits_wrapper & ) ;
} ;

}
#1 "./boost/regex/v4/match_flags.hpp"
#1 "./boost/cstdint.hpp"
#27 "./boost/regex/v4/match_flags.hpp"
namespace boost {
namespace regex_constants {


typedef enum _match_flags
{
match_default = 0 ,
match_not_bol = 1 ,
match_not_eol = match_not_bol << 1 ,
match_not_bob = match_not_eol << 1 ,
match_not_eob = match_not_bob << 1 ,
match_not_bow = match_not_eob << 1 ,
match_not_eow = match_not_bow << 1 ,
match_not_dot_newline = match_not_eow << 1 ,
match_not_dot_null = match_not_dot_newline << 1 ,
match_prev_avail = match_not_dot_null << 1 ,
match_init = match_prev_avail << 1 ,
match_any = match_init << 1 ,
match_not_null = match_any << 1 ,
match_continuous = match_not_null << 1 ,

match_partial = match_continuous << 1 ,

match_stop = match_partial << 1 ,
match_not_initial_null = match_stop ,
match_all = match_stop << 1 ,
match_perl = match_all << 1 ,
match_posix = match_perl << 1 ,
match_nosubs = match_posix << 1 ,
match_extra = match_nosubs << 1 ,
match_single_line = match_extra << 1 ,
match_unused1 = match_single_line << 1 ,
match_unused2 = match_unused1 << 1 ,
match_unused3 = match_unused2 << 1 ,
match_max = match_unused3 ,

format_perl = 0 ,
format_default = 0 ,
format_sed = match_max << 1 ,
format_all = format_sed << 1 ,
format_no_copy = format_all << 1 ,
format_first_only = format_no_copy << 1 ,
format_is_if = format_first_only << 1 ,
format_literal = format_is_if << 1

} match_flags ;




typedef match_flags match_flag_type ;



inline match_flags operator & ( match_flags m1 , match_flags m2 )
{ return static_cast < match_flags > ( static_cast < boost :: int32_t > ( m1 ) & static_cast < boost :: int32_t > ( m2 )
#82
) ; }
inline match_flags operator | ( match_flags m1 , match_flags m2 )
{ return static_cast < match_flags > ( static_cast < boost :: int32_t > ( m1 ) | static_cast < boost :: int32_t > ( m2 )
#84
) ; }
inline match_flags operator ^ ( match_flags m1 , match_flags m2 )
{ return static_cast < match_flags > ( static_cast < boost :: int32_t > ( m1 ) ^ static_cast < boost :: int32_t > ( m2 )
#86
) ; }
inline match_flags operator ~ ( match_flags m1 )
{ return static_cast < match_flags > ( ~ static_cast < boost :: int32_t > ( m1 ) ) ; }
inline match_flags & operator &= ( match_flags & m1 , match_flags m2 )
{ m1 = m1 & m2 ; return m1 ; }
inline match_flags & operator |= ( match_flags & m1 , match_flags m2 )
{ m1 = m1 | m2 ; return m1 ; }
inline match_flags & operator ^= ( match_flags & m1 , match_flags m2 )
{ m1 = m1 ^ m2 ; return m1 ; }




}



using regex_constants :: match_flag_type ;
using regex_constants :: match_default ;
using regex_constants :: match_not_bol ;
using regex_constants :: match_not_eol ;
using regex_constants :: match_not_bob ;
using regex_constants :: match_not_eob ;
using regex_constants :: match_not_bow ;
using regex_constants :: match_not_eow ;
using regex_constants :: match_not_dot_newline ;
using regex_constants :: match_not_dot_null ;
using regex_constants :: match_prev_avail ;

using regex_constants :: match_any ;
using regex_constants :: match_not_null ;
using regex_constants :: match_continuous ;
using regex_constants :: match_partial ;

using regex_constants :: match_all ;
using regex_constants :: match_perl ;
using regex_constants :: match_posix ;
using regex_constants :: match_nosubs ;
using regex_constants :: match_extra ;
using regex_constants :: match_single_line ;

using regex_constants :: format_all ;
using regex_constants :: format_sed ;
using regex_constants :: format_perl ;
using regex_constants :: format_default ;
using regex_constants :: format_no_copy ;
using regex_constants :: format_first_only ;


}
#1 "./boost/regex/v4/regex_raw_buffer.hpp"
#31
namespace boost {
namespace re_detail {
#45
struct empty_padding { } ;

union padding
{
void * p ;
unsigned int i ;
} ;

template < int N >
struct padding3
{
enum {
padding_size = 8 ,
padding_mask = 7
} ;
} ;

template < >
struct padding3 < 2 >
{
enum {
padding_size = 2 ,
padding_mask = 1
} ;
} ;

template < >
struct padding3 < 4 >
{
enum {
padding_size = 4 ,
padding_mask = 3
} ;
} ;

template < >
struct padding3 < 8 >
{
enum {
padding_size = 8 ,
padding_mask = 7
} ;
} ;

template < >
struct padding3 < 16 >
{
enum {
padding_size = 16 ,
padding_mask = 15
} ;
} ;

enum {
padding_size = padding3 < sizeof ( padding ) > :: padding_size ,
padding_mask = padding3 < sizeof ( padding ) > :: padding_mask
} ;
#109
class raw_storage
{
public :
typedef std :: size_t size_type ;
typedef unsigned char * pointer ;
private :
pointer last , start , end ;
public :

raw_storage ( ) ;
raw_storage ( size_type n ) ;

~ raw_storage ( )
{
:: operator delete ( start ) ;
}

void resize ( size_type n ) ;

void * extend ( size_type n )
{
if ( size_type ( last - end ) < n )
resize ( n + ( end - start ) ) ;
register pointer result = end ;
end += n ;
return result ;
}

void * insert ( size_type pos , size_type n ) ;

size_type size ( )
{
return end - start ;
}

size_type capacity ( )
{
return last - start ;
}

void * data ( ) const
{
return start ;
}

size_type index ( void * ptr )
{
return static_cast < pointer > ( ptr ) - static_cast < pointer > ( data ( ) ) ;
}

void clear ( )
{
end = start ;
}

void align ( )
{

end = start + ( ( ( end - start ) + padding_mask ) & ~ padding_mask ) ;
}
void swap ( raw_storage & that )
{
std :: swap ( start , that . start ) ;
std :: swap ( end , that . end ) ;
std :: swap ( last , that . last ) ;
}
} ;

inline raw_storage :: raw_storage ( )
{
last = start = end = 0 ;
}

inline raw_storage :: raw_storage ( size_type n )
{
start = end = static_cast < pointer > ( :: operator new ( n ) ) ;

last = start + n ;
}
#201
}
}
#1 "./boost/regex/v4/char_regex_traits.hpp"
#34
namespace boost {

namespace deprecated {



template < class charT >
class char_regex_traits_i : public regex_traits < charT > { } ;

template < >
class char_regex_traits_i < char > : public regex_traits < char >
{
public :
typedef char char_type ;
typedef unsigned char uchar_type ;
typedef unsigned int size_type ;
typedef regex_traits < char > base_type ;

} ;


template < >
class char_regex_traits_i < wchar_t > : public regex_traits < wchar_t >
{
public :
typedef wchar_t char_type ;
typedef unsigned short uchar_type ;
typedef unsigned int size_type ;
typedef regex_traits < wchar_t > base_type ;

} ;

}
}
#1 "./boost/regex/v4/states.hpp"
#33
namespace boost {
namespace re_detail {
#42
enum mask_type
{
mask_take = 1 ,
mask_skip = 2 ,
mask_init = 4 ,
mask_any = mask_skip | mask_take ,
mask_all = mask_any
} ;





struct _narrow_type { } ;
struct _wide_type { } ;
template < class charT > struct is_byte ;
template < > struct is_byte < char > { typedef _narrow_type width_type ; } ;
template < > struct is_byte < unsigned char > { typedef _narrow_type width_type ; } ;
template < > struct is_byte < signed char > { typedef _narrow_type width_type ; } ;
template < class charT > struct is_byte { typedef _wide_type width_type ; } ;




enum syntax_element_type
{

syntax_element_startmark = 0 ,

syntax_element_endmark = syntax_element_startmark + 1 ,

syntax_element_literal = syntax_element_endmark + 1 ,

syntax_element_start_line = syntax_element_literal + 1 ,

syntax_element_end_line = syntax_element_start_line + 1 ,

syntax_element_wild = syntax_element_end_line + 1 ,

syntax_element_match = syntax_element_wild + 1 ,

syntax_element_word_boundary = syntax_element_match + 1 ,

syntax_element_within_word = syntax_element_word_boundary + 1 ,

syntax_element_word_start = syntax_element_within_word + 1 ,

syntax_element_word_end = syntax_element_word_start + 1 ,

syntax_element_buffer_start = syntax_element_word_end + 1 ,

syntax_element_buffer_end = syntax_element_buffer_start + 1 ,

syntax_element_backref = syntax_element_buffer_end + 1 ,

syntax_element_long_set = syntax_element_backref + 1 ,

syntax_element_set = syntax_element_long_set + 1 ,

syntax_element_jump = syntax_element_set + 1 ,

syntax_element_alt = syntax_element_jump + 1 ,

syntax_element_rep = syntax_element_alt + 1 ,

syntax_element_combining = syntax_element_rep + 1 ,

syntax_element_soft_buffer_end = syntax_element_combining + 1 ,

syntax_element_restart_continue = syntax_element_soft_buffer_end + 1 ,

syntax_element_dot_rep = syntax_element_restart_continue + 1 ,
syntax_element_char_rep = syntax_element_dot_rep + 1 ,
syntax_element_short_set_rep = syntax_element_char_rep + 1 ,
syntax_element_long_set_rep = syntax_element_short_set_rep + 1 ,

syntax_element_backstep = syntax_element_long_set_rep + 1 ,

syntax_element_assert_backref = syntax_element_backstep + 1 ,
syntax_element_toggle_case = syntax_element_assert_backref + 1 ,

syntax_element_recurse = syntax_element_toggle_case + 1
} ;
#131
struct re_syntax_base ;
#138
union offset_type
{
re_syntax_base * p ;
std :: ptrdiff_t i ;
} ;




struct re_syntax_base
{
syntax_element_type type ;
offset_type next ;
} ;




struct re_brace : public re_syntax_base
{


int index ;
bool icase ;
} ;




enum
{
dont_care = 1 ,
force_not_newline = 0 ,
force_newline = 2 ,

test_not_newline = 2 ,
test_newline = 3
} ;
struct re_dot : public re_syntax_base
{
unsigned char mask ;
} ;





struct re_literal : public re_syntax_base
{
unsigned int length ;
} ;




struct re_case : public re_syntax_base
{
bool icase ;
} ;
#205
template < class mask_type >
struct re_set_long : public re_syntax_base
{
unsigned int csingles , cranges , cequivalents ;
mask_type cclasses ;
mask_type cnclasses ;
bool isnot ;
bool singleton ;
} ;




struct re_set : public re_syntax_base
{
unsigned char _map [ 1 << 8 ] ;
} ;




struct re_jump : public re_syntax_base
{
offset_type alt ;
} ;




struct re_alt : public re_jump
{
unsigned char _map [ 1 << 8 ] ;
unsigned int can_be_null ;
} ;




struct re_repeat : public re_alt
{
std :: size_t min , max ;
int state_id ;
bool leading ;
bool greedy ;
} ;




struct re_recurse : public re_jump
{
int state_id ;
} ;
#264
enum re_jump_size_type
{
re_jump_size = ( sizeof ( re_jump ) + padding_mask ) & ~ ( padding_mask ) ,
re_repeater_size = ( sizeof ( re_repeat ) + padding_mask ) & ~ ( padding_mask ) ,
re_alt_size = ( sizeof ( re_alt ) + padding_mask ) & ~ ( padding_mask )
} ;





template < class charT , class traits >
struct regex_data ;

template < class iterator , class charT , class traits_type , class char_classT >
iterator re_is_set_member ( iterator next ,
iterator last ,
const re_set_long < char_classT > * set_ ,
const regex_data < charT , traits_type > & e , bool icase ) ;

}

}
#1 "./boost/regex/v4/regbase.hpp"
#33
namespace boost {




class regbase
{
public :
enum flag_type_
{
#53
perl_syntax_group = 0 ,
basic_syntax_group = 1 ,
literal = 2 ,
main_option_type = literal | basic_syntax_group | perl_syntax_group ,



no_bk_refs = 1 << 8 ,
no_perl_ex = 1 << 9 ,
no_mod_m = 1 << 10 ,
mod_x = 1 << 11 ,
mod_s = 1 << 12 ,
no_mod_s = 1 << 13 ,




no_char_classes = 1 << 8 ,
no_intervals = 1 << 9 ,
bk_plus_qm = 1 << 10 ,
bk_vbar = 1 << 11 ,
emacs_ex = 1 << 12 ,




no_escape_in_lists = 1 << 16 ,
newline_alt = 1 << 17 ,
no_except = 1 << 18 ,
failbit = 1 << 19 ,
icase = 1 << 20 ,
nocollate = 0 ,
collate = 1 << 21 ,
nosubs = 1 << 22 ,
save_subexpression_location = 1 << 23 ,
no_empty_expressions = 1 << 24 ,
optimize = 0 ,



basic = basic_syntax_group | collate | no_escape_in_lists ,
extended = no_bk_refs | collate | no_perl_ex | no_escape_in_lists ,
normal = 0 ,
emacs = basic_syntax_group | collate | emacs_ex | bk_vbar ,
awk = no_bk_refs | collate | no_perl_ex ,
grep = basic | newline_alt ,
egrep = extended | newline_alt ,
sed = basic ,
perl = normal ,
ECMAScript = normal ,
JavaScript = normal ,
JScript = normal
} ;
typedef unsigned int flag_type ;

enum restart_info
{
restart_any = 0 ,
restart_word = 1 ,
restart_line = 2 ,
restart_buf = 3 ,
restart_continue = 4 ,
restart_lit = 5 ,
restart_fixed_lit = 6 ,
restart_count = 7
} ;
} ;




namespace regex_constants {

enum flag_type_
{

no_except = :: boost :: regbase :: no_except ,
failbit = :: boost :: regbase :: failbit ,
literal = :: boost :: regbase :: literal ,
icase = :: boost :: regbase :: icase ,
nocollate = :: boost :: regbase :: nocollate ,
collate = :: boost :: regbase :: collate ,
nosubs = :: boost :: regbase :: nosubs ,
optimize = :: boost :: regbase :: optimize ,
bk_plus_qm = :: boost :: regbase :: bk_plus_qm ,
bk_vbar = :: boost :: regbase :: bk_vbar ,
no_intervals = :: boost :: regbase :: no_intervals ,
no_char_classes = :: boost :: regbase :: no_char_classes ,
no_escape_in_lists = :: boost :: regbase :: no_escape_in_lists ,
no_mod_m = :: boost :: regbase :: no_mod_m ,
mod_x = :: boost :: regbase :: mod_x ,
mod_s = :: boost :: regbase :: mod_s ,
no_mod_s = :: boost :: regbase :: no_mod_s ,
save_subexpression_location = :: boost :: regbase :: save_subexpression_location ,
no_empty_expressions = :: boost :: regbase :: no_empty_expressions ,

basic = :: boost :: regbase :: basic ,
extended = :: boost :: regbase :: extended ,
normal = :: boost :: regbase :: normal ,
emacs = :: boost :: regbase :: emacs ,
awk = :: boost :: regbase :: awk ,
grep = :: boost :: regbase :: grep ,
egrep = :: boost :: regbase :: egrep ,
sed = basic ,
perl = normal ,
ECMAScript = normal ,
JavaScript = normal ,
JScript = normal
} ;
typedef :: boost :: regbase :: flag_type syntax_option_type ;

}

}
#1 "./boost/regex/v4/iterator_traits.hpp"
#33
namespace boost {
namespace re_detail {
#115
template < class T >
struct regex_iterator_traits : public std :: iterator_traits < T > { } ;



}
}
#1 "./boost/regex/v4/basic_regex.hpp"
#1 "./boost/type_traits/is_same.hpp"
#1 "./boost/type_traits/config.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#1 "./boost/type_traits/integral_constant.hpp"
#1 "./boost/mpl/integral_c.hpp"
#1 "./boost/mpl/integral_c_fwd.hpp"
#20
namespace mpl_ {





template < typename T , T N > struct integral_c ;


}
namespace boost { namespace mpl { using :: mpl_ :: integral_c ; } }
#1 "./boost/mpl/aux_/integral_wrapper.hpp"
#40
namespace mpl_ {

template < typename T , T N >
struct integral_c
{
static const T value = N ;





typedef integral_c type ;

typedef T value_type ;
typedef integral_c_tag tag ;
#72
typedef integral_c < T , static_cast < T > ( ( value + 1 ) ) > next ;
typedef integral_c < T , static_cast < T > ( ( value - 1 ) ) > prior ;
#80
operator T ( ) const { return static_cast < T > ( this -> value ) ; }
} ;


template < typename T , T N >
T const integral_c < T , N > :: value ;


}
#37 "./boost/mpl/integral_c.hpp"
namespace mpl_ {

template < bool C >
struct integral_c < bool , C >
{
static const bool value = C ;
typedef integral_c_tag tag ;
typedef integral_c type ;
typedef bool value_type ;
operator bool ( ) const { return this -> value ; }
} ;
}
#13 "./boost/type_traits/integral_constant.hpp"
namespace boost {




template < class T , T val >

struct integral_constant : public mpl :: integral_c < T , val >
{
typedef integral_constant < T , val > type ;
} ;

template < > struct integral_constant < bool , true > : public mpl :: true_
{
#34
typedef integral_constant < bool , true > type ;
} ;
template < > struct integral_constant < bool , false > : public mpl :: false_
{
#45
typedef integral_constant < bool , false > type ;
} ;

typedef integral_constant < bool , true > true_type ;
typedef integral_constant < bool , false > false_type ;

}
#1 "./boost/mpl/aux_/lambda_support.hpp"
#33 "./boost/type_traits/is_same.hpp"
namespace boost {



template < typename T , typename U > struct is_same : public :: boost :: integral_constant < bool , false > { public : }
#37
;
template < typename T > struct is_same < T , T > : public :: boost :: integral_constant < bool , true > { public : } ;
#98
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/functional/hash.hpp"
#1 "./boost/functional/hash/hash.hpp"
#1 "./boost/functional/hash/hash_fwd.hpp"
#21
namespace boost
{
template < class T > struct hash ;




template < class T > void hash_combine ( std :: size_t & seed , T const & v ) ;


template < class It > std :: size_t hash_range ( It , It ) ;
template < class It > void hash_range ( std :: size_t & , It , It ) ;





}
#1 "./boost/functional/hash/detail/hash_float.hpp"
#1 "./boost/functional/hash/detail/float_functions.hpp"
#1 "./boost/config/no_tr1/cmath.hpp"
#111 "./boost/functional/hash/detail/float_functions.hpp"
namespace boost {
namespace hash_detail {



struct not_found {



inline operator float ( ) const { return 0 ; }
inline operator long double ( ) const { return 0 ; }
} ;



template < typename T > struct is ;
template < > struct is < float > { char x [ 10 ] ; } ;
template < > struct is < double > { char x [ 20 ] ; } ;
template < > struct is < long double > { char x [ 30 ] ; } ;
template < > struct is < boost :: hash_detail :: not_found > { char x [ 40 ] ; } ;



template < typename T > is < T > float_type ( T ) ;





template < typename Float > struct call_ldexp
{
typedef double float_type ;

inline double operator ( ) ( double a , int b ) const
{
using namespace std ;
return ldexp ( a , b ) ;
}
} ;





template < typename Float > struct call_frexp
{
typedef double float_type ;

inline double operator ( ) ( double a , int * b ) const
{
using namespace std ;
return frexp ( a , b ) ;
}
} ;
}
}
#175
namespace boost_hash_detect_float_functions {
template < class Float > boost :: hash_detail :: not_found ldexp ( Float , int ) ;
template < class Float > boost :: hash_detail :: not_found frexp ( Float , int * ) ;
}
#276
namespace boost_hash_detect_float_functions { template < class Float > boost :: hash_detail :: not_found ldexpf ( Float ,
#276
int ) ; } namespace boost { namespace hash_detail { namespace ldexpf_detect { using namespace std ; using namespace boost_hash_detect_float_functions
#276
; struct check { static float x ; static int y ; static const bool cpp = sizeof ( float_type ( ldexp ( x , y ) ) ) == sizeof
#276
( is < float > ) ; static const bool c99 = sizeof ( float_type ( ldexpf ( x , y ) ) ) == sizeof ( is < float > ) ; } ; }
#276
template < bool x > struct call_c99_ldexpf : boost :: hash_detail :: call_ldexp < double > { } ; template < > struct call_c99_ldexpf
#276
< true > { typedef float float_type ; template < typename T > inline float operator ( ) ( float a , T b ) const { using namespace
#276
std ; return ldexpf ( a , b ) ; } } ; template < bool x > struct call_cpp_ldexpf : call_c99_ldexpf < :: boost :: hash_detail
#276
:: ldexpf_detect :: check :: c99 > { } ; template < > struct call_cpp_ldexpf < true > { typedef float float_type ; template
#276
< typename T > inline float operator ( ) ( float a , T b ) const { using namespace std ; return ldexp ( a , b ) ; } } ; template
#276
< > struct call_ldexp < float > : call_cpp_ldexpf < :: boost :: hash_detail :: ldexpf_detect :: check :: cpp > { } ; } }
#276






namespace boost_hash_detect_float_functions { template < class Float > boost :: hash_detail :: not_found ldexpl ( Float ,
#282
int ) ; } namespace boost { namespace hash_detail { namespace ldexpl_detect { using namespace std ; using namespace boost_hash_detect_float_functions
#282
; struct check { static long double x ; static int y ; static const bool cpp = sizeof ( float_type ( ldexp ( x , y ) ) )
#282
== sizeof ( is < long double > ) ; static const bool c99 = sizeof ( float_type ( ldexpl ( x , y ) ) ) == sizeof ( is < long
#282
double > ) ; } ; } template < bool x > struct call_c99_ldexpl : boost :: hash_detail :: call_ldexp < double > { } ; template
#282
< > struct call_c99_ldexpl < true > { typedef long double float_type ; template < typename T > inline long double operator
#282
( ) ( long double a , T b ) const { using namespace std ; return ldexpl ( a , b ) ; } } ; template < bool x > struct call_cpp_ldexpl
#282
: call_c99_ldexpl < :: boost :: hash_detail :: ldexpl_detect :: check :: c99 > { } ; template < > struct call_cpp_ldexpl
#282
< true > { typedef long double float_type ; template < typename T > inline long double operator ( ) ( long double a , T b
#282
) const { using namespace std ; return ldexp ( a , b ) ; } } ; template < > struct call_ldexp < long double > : call_cpp_ldexpl
#282
< :: boost :: hash_detail :: ldexpl_detect :: check :: cpp > { } ; } }





namespace boost_hash_detect_float_functions { template < class Float > boost :: hash_detail :: not_found frexpf ( Float ,
#288
int * ) ; } namespace boost { namespace hash_detail { namespace frexpf_detect { using namespace std ; using namespace boost_hash_detect_float_functions
#288
; struct check { static float x ; static int * y ; static const bool cpp = sizeof ( float_type ( frexp ( x , y ) ) ) == sizeof
#288
( is < float > ) ; static const bool c99 = sizeof ( float_type ( frexpf ( x , y ) ) ) == sizeof ( is < float > ) ; } ; }
#288
template < bool x > struct call_c99_frexpf : boost :: hash_detail :: call_frexp < double > { } ; template < > struct call_c99_frexpf
#288
< true > { typedef float float_type ; template < typename T > inline float operator ( ) ( float a , T b ) const { using namespace
#288
std ; return frexpf ( a , b ) ; } } ; template < bool x > struct call_cpp_frexpf : call_c99_frexpf < :: boost :: hash_detail
#288
:: frexpf_detect :: check :: c99 > { } ; template < > struct call_cpp_frexpf < true > { typedef float float_type ; template
#288
< typename T > inline float operator ( ) ( float a , T b ) const { using namespace std ; return frexp ( a , b ) ; } } ; template
#288
< > struct call_frexp < float > : call_cpp_frexpf < :: boost :: hash_detail :: frexpf_detect :: check :: cpp > { } ; } }
#288






namespace boost_hash_detect_float_functions { template < class Float > boost :: hash_detail :: not_found frexpl ( Float ,
#294
int * ) ; } namespace boost { namespace hash_detail { namespace frexpl_detect { using namespace std ; using namespace boost_hash_detect_float_functions
#294
; struct check { static long double x ; static int * y ; static const bool cpp = sizeof ( float_type ( frexp ( x , y ) )
#294
) == sizeof ( is < long double > ) ; static const bool c99 = sizeof ( float_type ( frexpl ( x , y ) ) ) == sizeof ( is <
#294
long double > ) ; } ; } template < bool x > struct call_c99_frexpl : boost :: hash_detail :: call_frexp < double > { } ;
#294
template < > struct call_c99_frexpl < true > { typedef long double float_type ; template < typename T > inline long double
#294
operator ( ) ( long double a , T b ) const { using namespace std ; return frexpl ( a , b ) ; } } ; template < bool x > struct
#294
call_cpp_frexpl : call_c99_frexpl < :: boost :: hash_detail :: frexpl_detect :: check :: c99 > { } ; template < > struct
#294
call_cpp_frexpl < true > { typedef long double float_type ; template < typename T > inline long double operator ( ) ( long
#294
double a , T b ) const { using namespace std ; return frexp ( a , b ) ; } } ; template < > struct call_frexp < long double
#294
> : call_cpp_frexpl < :: boost :: hash_detail :: frexpl_detect :: check :: cpp > { } ; } }
#301
namespace boost
{
namespace hash_detail
{
template < typename Float1 , typename Float2 >
struct select_hash_type_impl {
typedef double type ;
} ;

template < >
struct select_hash_type_impl < float , float > {
typedef float type ;
} ;

template < >
struct select_hash_type_impl < long double , long double > {
typedef long double type ;
} ;
#326
template < typename Float >
struct select_hash_type : select_hash_type_impl <
typename call_ldexp < Float > :: float_type ,
typename call_frexp < Float > :: float_type
> { } ;
}
}
#1 "./boost/functional/hash/detail/limits.hpp"
#26
namespace boost
{
namespace hash_detail
{
template < class T >
struct limits : std :: numeric_limits < T > { } ;
#58
}
}
#1 "./boost/utility/enable_if.hpp"
#24
namespace boost
{

template < bool B , class T = void >
struct enable_if_c {
typedef T type ;
} ;

template < class T >
struct enable_if_c < false , T > { } ;

template < class Cond , class T = void >
struct enable_if : public enable_if_c < Cond :: value , T > { } ;

template < bool B , class T >
struct lazy_enable_if_c {
typedef typename T :: type type ;
} ;

template < class T >
struct lazy_enable_if_c < false , T > { } ;

template < class Cond , class T >
struct lazy_enable_if : public lazy_enable_if_c < Cond :: value , T > { } ;


template < bool B , class T = void >
struct disable_if_c {
typedef T type ;
} ;

template < class T >
struct disable_if_c < true , T > { } ;

template < class Cond , class T = void >
struct disable_if : public disable_if_c < Cond :: value , T > { } ;

template < bool B , class T >
struct lazy_disable_if_c {
typedef typename T :: type type ;
} ;

template < class T >
struct lazy_disable_if_c < true , T > { } ;

template < class Cond , class T >
struct lazy_disable_if : public lazy_disable_if_c < Cond :: value , T > { } ;

}
#1 "./boost/integer/static_log2.hpp"
#21
namespace boost {

namespace detail {

namespace static_log2_impl {
#44
typedef boost :: static_log2_argument_type argument_type ;
typedef boost :: static_log2_result_type result_type ;

template < result_type n >
struct choose_initial_n {

static const bool c = ( argument_type ( 1 ) << n << n ) != 0 ;



static const result_type value = ! c * n + choose_initial_n < 2 * c * n > :: value ;

} ;

template < >
struct choose_initial_n < 0 > {
static const result_type value = 0 ;
} ;




const result_type n_zero = 16 ;
const result_type initial_n = choose_initial_n < n_zero > :: value ;
#84
template < argument_type x , result_type n = initial_n >
struct static_log2_impl {

static const bool c = ( x >> n ) > 0 ;



static const result_type value = c * n + ( static_log2_impl < ( x >> c * n ) , n / 2 > :: value ) ;

} ;

template < >
struct static_log2_impl < 1 , 0 > {
static const result_type value = 0 ;
} ;

}
}
#109
template < static_log2_argument_type x >
struct static_log2 {




static const static_log2_result_type value = detail :: static_log2_impl :: static_log2_impl < x > :: value ;

} ;


template < >
struct static_log2 < 0 > { } ;

}
#1 "./boost/cstdint.hpp"
#1 "./boost/assert.hpp"
#1 "/usr/include/assert.h"
#51 "./boost/functional/hash/detail/hash_float.hpp"
namespace boost
{
namespace hash_detail
{
inline void hash_float_combine ( std :: size_t & seed , std :: size_t value )
{
seed ^= value + ( seed << 6 ) + ( seed >> 2 ) ;
}
#66
inline std :: size_t hash_binary ( char * ptr , std :: size_t length )
{
std :: size_t seed = 0 ;

if ( length >= sizeof ( std :: size_t ) ) {
seed = * ( std :: size_t * ) ptr ;
length -= sizeof ( std :: size_t ) ;
ptr += sizeof ( std :: size_t ) ;

while ( length >= sizeof ( std :: size_t ) ) {
std :: size_t buffer = 0 ;
std :: memcpy ( & buffer , ptr , sizeof ( std :: size_t ) ) ;
hash_float_combine ( seed , buffer ) ;
length -= sizeof ( std :: size_t ) ;
ptr += sizeof ( std :: size_t ) ;
}
}

if ( length > 0 ) {
std :: size_t buffer = 0 ;
std :: memcpy ( & buffer , ptr , length ) ;
hash_float_combine ( seed , buffer ) ;
}

return seed ;
}

template < typename Float >
inline std :: size_t float_hash_impl ( Float v ,
typename boost :: enable_if_c <
std :: numeric_limits < Float > :: is_iec559 &&
std :: numeric_limits < Float > :: digits == 24 &&
std :: numeric_limits < Float > :: radix == 2 &&
std :: numeric_limits < Float > :: max_exponent == 128 ,
int > :: type
)
{
return hash_binary ( ( char * ) & v , 4 ) ;
}


template < typename Float >
inline std :: size_t float_hash_impl ( Float v ,
typename boost :: enable_if_c <
std :: numeric_limits < Float > :: is_iec559 &&
std :: numeric_limits < Float > :: digits == 53 &&
std :: numeric_limits < Float > :: radix == 2 &&
std :: numeric_limits < Float > :: max_exponent == 1024 ,
int > :: type
)
{
return hash_binary ( ( char * ) & v , 8 ) ;
}

template < typename Float >
inline std :: size_t float_hash_impl ( Float v ,
typename boost :: enable_if_c <
std :: numeric_limits < Float > :: is_iec559 &&
std :: numeric_limits < Float > :: digits == 64 &&
std :: numeric_limits < Float > :: radix == 2 &&
std :: numeric_limits < Float > :: max_exponent == 16384 ,
int > :: type
)
{
return hash_binary ( ( char * ) & v , 10 ) ;
}

template < typename Float >
inline std :: size_t float_hash_impl ( Float v ,
typename boost :: enable_if_c <
std :: numeric_limits < Float > :: is_iec559 &&
std :: numeric_limits < Float > :: digits == 113 &&
std :: numeric_limits < Float > :: radix == 2 &&
std :: numeric_limits < Float > :: max_exponent == 16384 ,
int > :: type
)
{
return hash_binary ( ( char * ) & v , 16 ) ;
}
#151
template < class T >
inline std :: size_t float_hash_impl2 ( T v )
{
boost :: hash_detail :: call_frexp < T > frexp ;
boost :: hash_detail :: call_ldexp < T > ldexp ;

int exp = 0 ;

v = frexp ( v , & exp ) ;



if ( v < 0 ) {
v = - v ;
exp += limits < T > :: max_exponent -
limits < T > :: min_exponent ;
}

v = ldexp ( v , limits < std :: size_t > :: digits ) ;
std :: size_t seed = static_cast < std :: size_t > ( v ) ;
v -= static_cast < T > ( seed ) ;


std :: size_t const length
= ( limits < T > :: digits *
boost :: static_log2 < limits < T > :: radix > :: value
+ limits < std :: size_t > :: digits - 1 )
/ limits < std :: size_t > :: digits ;

for ( std :: size_t i = 0 ; i != length ; ++ i )
{
v = ldexp ( v , limits < std :: size_t > :: digits ) ;
std :: size_t part = static_cast < std :: size_t > ( v ) ;
v -= static_cast < T > ( part ) ;
hash_float_combine ( seed , part ) ;
}

hash_float_combine ( seed , exp ) ;

return seed ;
}


template < class T >
inline std :: size_t float_hash_impl ( T v , ... )
{
typedef typename select_hash_type < T > :: type type ;
return float_hash_impl2 ( static_cast < type > ( v ) ) ;
}

}
}
#208
namespace boost
{
namespace hash_detail
{
template < class T >
inline std :: size_t float_hash_value ( T v )
{





using namespace std ;
switch ( fpclassify ( v ) )

{
case 0 :
return 0 ;
case 3 :
return ( std :: size_t ) ( v > 0 ? - 1 : - 2 ) ;
case 4 :
return ( std :: size_t ) ( - 3 ) ;
case 2 :
case 1 :
return float_hash_impl ( v , 0 ) ;
default :
( ( void ) 0 ) ;
return 0 ;
}
}
}
}
#1 "./boost/type_traits/is_enum.hpp"
#1 "./boost/type_traits/intrinsics.hpp"
#1 "./boost/type_traits/add_reference.hpp"
#1 "./boost/type_traits/is_reference.hpp"
#1 "./boost/type_traits/is_lvalue_reference.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#34 "./boost/type_traits/is_lvalue_reference.hpp"
namespace boost {





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

template < typename T > struct is_lvalue_reference < T & > : public :: boost :: integral_constant < bool , true > { public
#41
: } ;
#113
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/is_rvalue_reference.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#17 "./boost/type_traits/is_rvalue_reference.hpp"
namespace boost {

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





}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/ice.hpp"
#1 "./boost/type_traits/detail/yes_no_type.hpp"
#14
namespace boost {
namespace type_traits {

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

}
}
#1 "./boost/type_traits/detail/ice_or.hpp"
#13
namespace boost {
namespace type_traits {

template < bool b1 , bool b2 , bool b3 = false , bool b4 = false , bool b5 = false , bool b6 = false , bool b7 = false >
#16

struct ice_or ;

template < bool b1 , bool b2 , bool b3 , bool b4 , bool b5 , bool b6 , bool b7 >
struct ice_or
{
static const bool value = true ;
} ;

template < >
struct ice_or < false , false , false , false , false , false , false >
{
static const bool value = false ;
} ;

}
}
#1 "./boost/type_traits/detail/ice_and.hpp"
#14
namespace boost {
namespace type_traits {

template < bool b1 , bool b2 , bool b3 = true , bool b4 = true , bool b5 = true , bool b6 = true , bool b7 = true >
struct ice_and ;

template < bool b1 , bool b2 , bool b3 , bool b4 , bool b5 , bool b6 , bool b7 >
struct ice_and
{
static const bool value = false ;
} ;

template < >
struct ice_and < true , true , true , true , true , true , true >
{
static const bool value = true ;
} ;

}
}
#1 "./boost/type_traits/detail/ice_not.hpp"
#13
namespace boost {
namespace type_traits {

template < bool b >
struct ice_not
{
static const bool value = true ;
} ;

template < >
struct ice_not < true >
{
static const bool value = false ;
} ;

}
}
#1 "./boost/type_traits/detail/ice_eq.hpp"
#13
namespace boost {
namespace type_traits {

template < int b1 , int b2 >
struct ice_eq
{
static const bool value = ( b1 == b2 ) ;
} ;

template < int b1 , int b2 >
struct ice_ne
{
static const bool value = ( b1 != b2 ) ;
} ;


template < int b1 , int b2 > bool const ice_eq < b1 , b2 > :: value ;
template < int b1 , int b2 > bool const ice_ne < b1 , b2 > :: value ;


}
}
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#23 "./boost/type_traits/is_reference.hpp"
namespace boost {

namespace detail {

template < typename T >
struct is_reference_impl
{



static const bool value = ( :: boost :: type_traits :: ice_or < :: boost :: is_lvalue_reference < T > :: value , :: boost
#33
:: is_rvalue_reference < T > :: value > :: value ) ;
} ;

}

template < typename T > struct is_reference : public :: boost :: integral_constant < bool , :: boost :: detail :: is_reference_impl
#38
< T > :: value > { public : } ;

}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/type_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#19 "./boost/type_traits/add_reference.hpp"
namespace boost {

namespace detail {
#59
template < typename T >
struct add_reference_rvalue_layer
{
typedef T & type ;
} ;
#73
template < typename T >
struct add_reference_impl
{
typedef typename add_reference_rvalue_layer < T > :: type type ;
} ;


template < typename T > struct add_reference_impl < T & > { public : typedef T & type ; } ;





template < > struct add_reference_impl < void > { public : typedef void type ; } ;

template < > struct add_reference_impl < void const > { public : typedef void const type ; } ;
template < > struct add_reference_impl < void volatile > { public : typedef void volatile type ; } ;
template < > struct add_reference_impl < void const volatile > { public : typedef void const volatile type ; } ;


}

template < typename T > struct add_reference { public : typedef typename boost :: detail :: add_reference_impl < T > :: type
#95
type ; } ;
#103
}
#1 "./boost/type_traits/detail/type_trait_undef.hpp"
#1 "./boost/type_traits/is_arithmetic.hpp"
#1 "./boost/type_traits/is_integral.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#17 "./boost/type_traits/is_integral.hpp"
namespace boost {
#25
template < typename T > struct is_integral : public :: boost :: integral_constant < bool , false > { public : } ;

template < > struct is_integral < unsigned char > : public :: boost :: integral_constant < bool , true > { public : } ; template
#27
< > struct is_integral < unsigned char const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#27
< > struct is_integral < unsigned char volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#27
< > struct is_integral < unsigned char const volatile > : public :: boost :: integral_constant < bool , true > { public :
#27
} ;
template < > struct is_integral < unsigned short > : public :: boost :: integral_constant < bool , true > { public : } ;
#28
template < > struct is_integral < unsigned short const > : public :: boost :: integral_constant < bool , true > { public
#28
: } ; template < > struct is_integral < unsigned short volatile > : public :: boost :: integral_constant < bool , true >
#28
{ public : } ; template < > struct is_integral < unsigned short const volatile > : public :: boost :: integral_constant <
#28
bool , true > { public : } ;
template < > struct is_integral < unsigned int > : public :: boost :: integral_constant < bool , true > { public : } ; template
#29
< > struct is_integral < unsigned int const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#29
< > struct is_integral < unsigned int volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#29
< > struct is_integral < unsigned int const volatile > : public :: boost :: integral_constant < bool , true > { public :
#29
} ;
template < > struct is_integral < unsigned long > : public :: boost :: integral_constant < bool , true > { public : } ; template
#30
< > struct is_integral < unsigned long const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#30
< > struct is_integral < unsigned long volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#30
< > struct is_integral < unsigned long const volatile > : public :: boost :: integral_constant < bool , true > { public :
#30
} ;

template < > struct is_integral < signed char > : public :: boost :: integral_constant < bool , true > { public : } ; template
#32
< > struct is_integral < signed char const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#32
< > struct is_integral < signed char volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#32
< > struct is_integral < signed char const volatile > : public :: boost :: integral_constant < bool , true > { public : }
#32
;
template < > struct is_integral < signed short > : public :: boost :: integral_constant < bool , true > { public : } ; template
#33
< > struct is_integral < signed short const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#33
< > struct is_integral < signed short volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#33
< > struct is_integral < signed short const volatile > : public :: boost :: integral_constant < bool , true > { public :
#33
} ;
template < > struct is_integral < signed int > : public :: boost :: integral_constant < bool , true > { public : } ; template
#34
< > struct is_integral < signed int const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#34
< > struct is_integral < signed int volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#34
< > struct is_integral < signed int const volatile > : public :: boost :: integral_constant < bool , true > { public : }
#34
;
template < > struct is_integral < signed long > : public :: boost :: integral_constant < bool , true > { public : } ; template
#35
< > struct is_integral < signed long const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#35
< > struct is_integral < signed long volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#35
< > struct is_integral < signed long const volatile > : public :: boost :: integral_constant < bool , true > { public : }
#35
;

template < > struct is_integral < bool > : public :: boost :: integral_constant < bool , true > { public : } ; template <
#37
> struct is_integral < bool const > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct
#37
is_integral < bool volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct is_integral
#37
< bool const volatile > : public :: boost :: integral_constant < bool , true > { public : } ;
template < > struct is_integral < char > : public :: boost :: integral_constant < bool , true > { public : } ; template <
#38
> struct is_integral < char const > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct
#38
is_integral < char volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct is_integral
#38
< char const volatile > : public :: boost :: integral_constant < bool , true > { public : } ;





template < > struct is_integral < wchar_t > : public :: boost :: integral_constant < bool , true > { public : } ; template
#44
< > struct is_integral < wchar_t const > : public :: boost :: integral_constant < bool , true > { public : } ; template <
#44
> struct is_integral < wchar_t volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#44
< > struct is_integral < wchar_t const volatile > : public :: boost :: integral_constant < bool , true > { public : } ;
#65
template < > struct is_integral < :: boost :: ulong_long_type > : public :: boost :: integral_constant < bool , true > {
#65
public : } ; template < > struct is_integral < :: boost :: ulong_long_type const > : public :: boost :: integral_constant
#65
< bool , true > { public : } ; template < > struct is_integral < :: boost :: ulong_long_type volatile > : public :: boost
#65
:: integral_constant < bool , true > { public : } ; template < > struct is_integral < :: boost :: ulong_long_type const volatile
#65
> : public :: boost :: integral_constant < bool , true > { public : } ;
template < > struct is_integral < :: boost :: long_long_type > : public :: boost :: integral_constant < bool , true > { public
#66
: } ; template < > struct is_integral < :: boost :: long_long_type const > : public :: boost :: integral_constant < bool
#66
, true > { public : } ; template < > struct is_integral < :: boost :: long_long_type volatile > : public :: boost :: integral_constant
#66
< bool , true > { public : } ; template < > struct is_integral < :: boost :: long_long_type const volatile > : public ::
#66
boost :: integral_constant < bool , true > { public : } ;
#79
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/is_float.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#15 "./boost/type_traits/is_float.hpp"
namespace boost {


template < typename T > struct is_float : public :: boost :: integral_constant < bool , false > { public : } ;
template < > struct is_float < float > : public :: boost :: integral_constant < bool , true > { public : } ; template < >
#19
struct is_float < float const > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct
#19
is_float < float volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct is_float
#19
< float const volatile > : public :: boost :: integral_constant < bool , true > { public : } ;
template < > struct is_float < double > : public :: boost :: integral_constant < bool , true > { public : } ; template <
#20
> struct is_float < double const > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct
#20
is_float < double volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template < > struct is_float
#20
< double const volatile > : public :: boost :: integral_constant < bool , true > { public : } ;
template < > struct is_float < long double > : public :: boost :: integral_constant < bool , true > { public : } ; template
#21
< > struct is_float < long double const > : public :: boost :: integral_constant < bool , true > { public : } ; template
#21
< > struct is_float < long double volatile > : public :: boost :: integral_constant < bool , true > { public : } ; template
#21
< > struct is_float < long double const volatile > : public :: boost :: integral_constant < bool , true > { public : } ;
#21


}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#22 "./boost/type_traits/is_arithmetic.hpp"
namespace boost {


namespace detail {

template < typename T >
struct is_arithmetic_impl
{




static const bool value = ( :: boost :: type_traits :: ice_or < :: boost :: is_integral < T > :: value , :: boost :: is_float
#34
< T > :: value > :: value ) ;
} ;

}
#44
template < typename T > struct is_arithmetic : public :: boost :: integral_constant < bool , :: boost :: detail :: is_arithmetic_impl
#44
< T > :: value > { public : } ;


}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/is_convertible.hpp"
#1 "./boost/type_traits/is_array.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#29 "./boost/type_traits/is_array.hpp"
namespace boost {




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

template < typename T , std :: size_t N > struct is_array < T [ N ] > : public :: boost :: integral_constant < bool , true
#36
> { public : } ;
template < typename T , std :: size_t N > struct is_array < T const [ N ] > : public :: boost :: integral_constant < bool
#37
, true > { public : } ;
template < typename T , std :: size_t N > struct is_array < T volatile [ N ] > : public :: boost :: integral_constant < bool
#38
, true > { public : } ;
template < typename T , std :: size_t N > struct is_array < T const volatile [ N ] > : public :: boost :: integral_constant
#39
< bool , true > { public : } ;

template < typename T > struct is_array < T [ ] > : public :: boost :: integral_constant < bool , true > { public : } ;
template < typename T > struct is_array < T const [ ] > : public :: boost :: integral_constant < bool , true > { public :
#42
} ;
template < typename T > struct is_array < T volatile [ ] > : public :: boost :: integral_constant < bool , true > { public
#43
: } ;
template < typename T > struct is_array < T const volatile [ ] > : public :: boost :: integral_constant < bool , true > {
#44
public : } ;
#87
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/is_void.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#17 "./boost/type_traits/is_void.hpp"
namespace boost {





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


template < > struct is_void < void const > : public :: boost :: integral_constant < bool , true > { public : } ;
template < > struct is_void < void volatile > : public :: boost :: integral_constant < bool , true > { public : } ;
template < > struct is_void < void const volatile > : public :: boost :: integral_constant < bool , true > { public : } ;
#29





}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/is_abstract.hpp"
#1 "./boost/type_traits/is_class.hpp"
#1 "./boost/type_traits/is_union.hpp"
#1 "./boost/type_traits/remove_cv.hpp"
#1 "./boost/type_traits/broken_compiler_spec.hpp"
#1 "./boost/type_traits/detail/cv_traits_impl.hpp"
#23
namespace boost {
namespace detail {
#32
template < typename T > struct cv_traits_imp { } ;

template < typename T >
struct cv_traits_imp < T * >
{
static const bool is_const = false ;
static const bool is_volatile = false ;
typedef T unqualified_type ;
} ;

template < typename T >
struct cv_traits_imp < const T * >
{
static const bool is_const = true ;
static const bool is_volatile = false ;
typedef T unqualified_type ;
} ;

template < typename T >
struct cv_traits_imp < volatile T * >
{
static const bool is_const = false ;
static const bool is_volatile = true ;
typedef T unqualified_type ;
} ;

template < typename T >
struct cv_traits_imp < const volatile T * >
{
static const bool is_const = true ;
static const bool is_volatile = true ;
typedef T unqualified_type ;
} ;
#92
}
}
#1 "./boost/type_traits/detail/type_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#28 "./boost/type_traits/remove_cv.hpp"
namespace boost {



namespace detail {

template < class T >
struct rvalue_ref_filter_rem_cv
{
typedef typename boost :: detail :: cv_traits_imp < T * > :: unqualified_type type ;
} ;
#52
}



template < typename T > struct remove_cv { public : typedef typename boost :: detail :: rvalue_ref_filter_rem_cv < T > ::
#56
type type ; } ;
template < typename T > struct remove_cv < T & > { public : typedef T & type ; } ;

template < typename T , std :: size_t N > struct remove_cv < T const [ N ] > { public : typedef T type [ N ] ; } ;
template < typename T , std :: size_t N > struct remove_cv < T volatile [ N ] > { public : typedef T type [ N ] ; } ;
template < typename T , std :: size_t N > struct remove_cv < T const volatile [ N ] > { public : typedef T type [ N ] ; }
#61
;
#80
}
#1 "./boost/type_traits/detail/type_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#21 "./boost/type_traits/is_union.hpp"
namespace boost {

namespace detail {

template < typename T > struct is_union_impl
{
typedef typename remove_cv < T > :: type cvt ;



static const bool value = false ;

} ;
#49
}

template < typename T > struct is_union : public :: boost :: integral_constant < bool , :: boost :: detail :: is_union_impl
#51
< T > :: value > { public : } ;

}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#39 "./boost/type_traits/is_class.hpp"
namespace boost {

namespace detail {
#75
template < typename T >
struct is_class_impl
{
template < class U > static :: boost :: type_traits :: yes_type is_class_tester ( void ( U :: * ) ( void ) ) ;
template < class U > static :: boost :: type_traits :: no_type is_class_tester ( ... ) ;
#86
static const bool value = ( :: boost :: type_traits :: ice_and < sizeof ( is_class_tester < T > ( 0 ) ) == sizeof ( :: boost
#86
:: type_traits :: yes_type ) , :: boost :: type_traits :: ice_not < :: boost :: is_union < T > :: value > :: value > :: value
#86
) ;
} ;
#127
}





template < typename T > struct is_class : public :: boost :: integral_constant < bool , :: boost :: detail :: is_class_impl
#133
< T > :: value > { public : } ;


}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#65 "./boost/type_traits/is_abstract.hpp"
namespace boost {
namespace detail {
#75
template < class T >
struct is_abstract_imp2
{




template < class U >
static type_traits :: no_type check_sig ( U ( * ) [ 1 ] ) ;
template < class U >
static type_traits :: yes_type check_sig ( ... ) ;




typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( sizeof ( T ) != 0 ) >
#90
) > boost_static_assert_typedef_90 ;
#101
static const std :: size_t s1 = sizeof ( check_sig < T > ( 0 ) ) ;
#108
static const bool value = ( s1 == sizeof ( type_traits :: yes_type ) ) ;
} ;

template < bool v >
struct is_abstract_select
{
template < class T >
struct rebind
{
typedef is_abstract_imp2 < T > type ;
} ;
} ;
template < >
struct is_abstract_select < false >
{
template < class T >
struct rebind
{
typedef false_type type ;
} ;
} ;

template < class T >
struct is_abstract_imp
{
typedef is_abstract_select < :: boost :: is_class < T > :: value > selector ;
typedef typename selector :: template rebind < T > binder ;
typedef typename binder :: type type ;

static const bool value = type :: value ;
} ;


}


template < typename T > struct is_abstract : public :: boost :: integral_constant < bool , :: boost :: detail :: is_abstract_imp
#144
< T > :: value > { public : } ;




}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/add_lvalue_reference.hpp"
#1 "./boost/type_traits/detail/type_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#14 "./boost/type_traits/add_lvalue_reference.hpp"
namespace boost {

template < typename T > struct add_lvalue_reference { public : typedef typename boost :: add_reference < T > :: type type
#16
; } ;





}
#1 "./boost/type_traits/detail/type_trait_undef.hpp"
#1 "./boost/type_traits/add_rvalue_reference.hpp"
#1 "./boost/type_traits/detail/type_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#34 "./boost/type_traits/add_rvalue_reference.hpp"
namespace boost {

namespace type_traits_detail {

template < typename T , bool b >
struct add_rvalue_reference_helper
{ typedef T type ; } ;
#50
template < typename T >
struct add_rvalue_reference_imp
{
typedef typename boost :: type_traits_detail :: add_rvalue_reference_helper
< T , ( is_void < T > :: value == false && is_reference < T > :: value == false ) > :: type type ;
} ;

}

template < typename T > struct add_rvalue_reference { public : typedef typename boost :: type_traits_detail :: add_rvalue_reference_imp
#59
< T > :: type type ; } ;

}
#1 "./boost/type_traits/detail/type_trait_undef.hpp"
#1 "./boost/type_traits/is_function.hpp"
#1 "./boost/type_traits/detail/false_result.hpp"
#14
namespace boost {
namespace type_traits {


struct false_result
{
template < typename T > struct result_
{
static const bool value = false ;
} ;
} ;

} }
#1 "./boost/type_traits/detail/is_function_ptr_helper.hpp"
#26
namespace boost {
namespace type_traits {

template < class R >
struct is_function_ptr_helper
{
static const bool value = false ;
} ;




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

template < class R >
struct is_function_ptr_helper < R ( * ) ( ... ) > { static const bool value = true ; } ;

template < class R , class T0 >
struct is_function_ptr_helper < R ( * ) ( T0 ) > { static const bool value = true ; } ;

template < class R , class T0 >
struct is_function_ptr_helper < R ( * ) ( T0 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ... ) > { static const bool value = true ; } ;
#84


template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) > { static const bool value = true ; }
#87
;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ... ) > { static const bool value = true
#90
; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) > { static const bool value = true
#93
; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ... ) > { static const bool value =
#96
true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#98
T9 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) > { static const bool value =
#99
true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#101
T9 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ... ) > { static const bool value
#102
= true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#104
T9 , class T10 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) > { static const bool value
#105
= true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#107
T9 , class T10 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ... ) > { static const bool
#108
value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#110
T9 , class T10 , class T11 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) > { static const
#111
bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#113
T9 , class T10 , class T11 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ... ) > { static const
#114
bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#116
T9 , class T10 , class T11 , class T12 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) > { static
#117
const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#119
T9 , class T10 , class T11 , class T12 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ... ) > { static
#120
const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#122
T9 , class T10 , class T11 , class T12 , class T13 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) > { static
#123
const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#125
T9 , class T10 , class T11 , class T12 , class T13 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ... ) >
#126
{ static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#128
T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 )
#129
> { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#131
T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...
#132
) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#134
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#135
T15 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#137
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#138
T15 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#140
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#141
T15 , T16 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#143
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#144
T15 , T16 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#146
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#147
T15 , T16 , T17 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#149
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#150
T15 , T16 , T17 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#152
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#153
T15 , T16 , T17 , T18 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#155
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#156
T15 , T16 , T17 , T18 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#158
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#158
>
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#159
T15 , T16 , T17 , T18 , T19 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#161
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#161
>
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#162
T15 , T16 , T17 , T18 , T19 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#164
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#164
, class T20 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#165
T15 , T16 , T17 , T18 , T19 , T20 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#167
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#167
, class T20 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#168
T15 , T16 , T17 , T18 , T19 , T20 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#170
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#170
, class T20 , class T21 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#171
T15 , T16 , T17 , T18 , T19 , T20 , T21 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#173
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#173
, class T20 , class T21 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#174
T15 , T16 , T17 , T18 , T19 , T20 , T21 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#176
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#176
, class T20 , class T21 , class T22 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#177
T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#179
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#179
, class T20 , class T21 , class T22 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#180
T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#182
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#182
, class T20 , class T21 , class T22 , class T23 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#183
T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#185
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#185
, class T20 , class T21 , class T22 , class T23 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#186
T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ... ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#188
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#188
, class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#189
T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ) > { static const bool value = true ; } ;

template < class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class
#191
T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19
#191
, class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_function_ptr_helper < R ( * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ,
#192
T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ... ) > { static const bool value = true ; } ;
#203
}
}
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#34 "./boost/type_traits/is_function.hpp"
namespace boost {



namespace detail {


template < bool is_ref = true >
struct is_function_chooser
: public :: boost :: type_traits :: false_result
{
} ;

template < >
struct is_function_chooser < false >
{
template < typename T > struct result_
: public :: boost :: type_traits :: is_function_ptr_helper < T * >
{
} ;
} ;

template < typename T >
struct is_function_impl
: public is_function_chooser < :: boost :: is_reference < T > :: value >
:: template result_ < T >
{
} ;
#95
}
#102
template < typename T > struct is_function : public :: boost :: integral_constant < bool , :: boost :: detail :: is_function_impl
#102
< T > :: value > { public : } ;




}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#39 "./boost/type_traits/is_convertible.hpp"
namespace boost {
#53
namespace detail {
#300
template < typename From , typename To >
struct is_convertible_basic_impl
{
static :: boost :: type_traits :: no_type _m_check ( ... ) ;
static :: boost :: type_traits :: yes_type _m_check ( To ) ;
typedef typename add_lvalue_reference < From > :: type lvalue_type ;
typedef typename add_rvalue_reference < From > :: type rvalue_type ;
static lvalue_type _m_from ;
#322
static const bool value = sizeof ( _m_check ( _m_from ) ) == sizeof ( :: boost :: type_traits :: yes_type ) ;




} ;
#351
template < typename From , typename To >
struct is_convertible_impl
{
#367
static const bool value = ( :: boost :: type_traits :: ice_and < :: boost :: type_traits :: ice_or < :: boost :: detail ::
#367
is_convertible_basic_impl < From , To > :: value , :: boost :: is_void < To > :: value > :: value , :: boost :: type_traits
#367
:: ice_not < :: boost :: is_array < To > :: value > :: value , :: boost :: type_traits :: ice_not < :: boost :: is_function
#367
< To > :: value > :: value > :: value ) ;
} ;


template < bool trivial1 , bool trivial2 , bool abstract_target >
struct is_convertible_impl_select
{
template < class From , class To >
struct rebind
{
typedef is_convertible_impl < From , To > type ;
} ;
} ;

template < >
struct is_convertible_impl_select < true , true , false >
{
template < class From , class To >
struct rebind
{
typedef true_type type ;
} ;
} ;

template < >
struct is_convertible_impl_select < false , false , true >
{
template < class From , class To >
struct rebind
{
typedef false_type type ;
} ;
} ;

template < >
struct is_convertible_impl_select < true , false , true >
{
template < class From , class To >
struct rebind
{
typedef false_type type ;
} ;
} ;

template < typename From , typename To >
struct is_convertible_impl_dispatch_base
{

typedef is_convertible_impl_select <
:: boost :: is_arithmetic < From > :: value ,
:: boost :: is_arithmetic < To > :: value ,

:: boost :: is_abstract < To > :: value



> selector ;



typedef typename selector :: template rebind < From , To > isc_binder ;
typedef typename isc_binder :: type type ;
} ;

template < typename From , typename To >
struct is_convertible_impl_dispatch
: public is_convertible_impl_dispatch_base < From , To > :: type
{ } ;
#456
template < > struct is_convertible_impl < void , void > { public : static const bool value = ( true ) ; } ; template < >
#456
struct is_convertible_impl < void , void const > { public : static const bool value = ( true ) ; } ; template < > struct
#456
is_convertible_impl < void , void volatile > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl
#456
< void , void const volatile > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl
#456
< void const , void > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void
#456
const , void const > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void const
#456
, void volatile > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void const
#456
, void const volatile > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void
#456
volatile , void > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void volatile
#456
, void const > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void volatile
#456
, void volatile > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void volatile
#456
, void const volatile > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void
#456
const volatile , void > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl < void
#456
const volatile , void const > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl
#456
< void const volatile , void volatile > { public : static const bool value = ( true ) ; } ; template < > struct is_convertible_impl
#456
< void const volatile , void const volatile > { public : static const bool value = ( true ) ; } ;
#466
template < typename To > struct is_convertible_impl < void , To > { public : static const bool value = ( false ) ; } ;
template < typename From > struct is_convertible_impl < From , void > { public : static const bool value = ( false ) ; }
#467
;

template < typename To > struct is_convertible_impl < void const , To > { public : static const bool value = ( false ) ;
#469
} ;
template < typename To > struct is_convertible_impl < void volatile , To > { public : static const bool value = ( false )
#470
; } ;
template < typename To > struct is_convertible_impl < void const volatile , To > { public : static const bool value = ( false
#471
) ; } ;
template < typename From > struct is_convertible_impl < From , void const > { public : static const bool value = ( false
#472
) ; } ;
template < typename From > struct is_convertible_impl < From , void volatile > { public : static const bool value = ( false
#473
) ; } ;
template < typename From > struct is_convertible_impl < From , void const volatile > { public : static const bool value =
#474
( false ) ; } ;



}

template < typename From , typename To > struct is_convertible : public :: boost :: integral_constant < bool , ( :: boost
#480
:: detail :: is_convertible_impl_dispatch < From , To > :: value ) > { public : } ;
#488
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#34 "./boost/type_traits/is_enum.hpp"
namespace boost {




namespace detail {



template < typename T >
struct is_class_or_union
{




static const bool value = ( :: boost :: type_traits :: ice_or < :: boost :: is_class < T > :: value , :: boost :: is_union
#50
< T > :: value > :: value ) ;
} ;
#78
struct int_convertible
{
int_convertible ( int ) ;
} ;



template < bool is_typename_arithmetic_or_reference = true >
struct is_enum_helper
{
template < typename T > struct type
{
static const bool value = false ;
} ;
} ;

template < >
struct is_enum_helper < false >
{
template < typename T > struct type
: public :: boost :: is_convertible < typename boost :: add_reference < T > :: type , :: boost :: detail :: int_convertible
#98
>
{
} ;
} ;

template < typename T > struct is_enum_impl
{
#143
static const bool selector = ( :: boost :: type_traits :: ice_or < :: boost :: is_arithmetic < T > :: value , :: boost ::
#143
is_reference < T > :: value , is_class_or_union < T > :: value , is_array < T > :: value > :: value ) ;
#152
typedef :: boost :: detail :: is_enum_helper < selector > se_t ;


typedef typename se_t :: template type < T > helper ;
static const bool value = helper :: value ;
} ;


template < > struct is_enum_impl < void > { public : static const bool value = ( false ) ; } ;

template < > struct is_enum_impl < void const > { public : static const bool value = ( false ) ; } ;
template < > struct is_enum_impl < void volatile > { public : static const bool value = ( false ) ; } ;
template < > struct is_enum_impl < void const volatile > { public : static const bool value = ( false ) ; } ;


}

template < typename T > struct is_enum : public :: boost :: integral_constant < bool , :: boost :: detail :: is_enum_impl
#169
< T > :: value > { public : } ;
#185
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#37 "./boost/functional/hash/hash.hpp"
namespace boost
{
namespace hash_detail
{
struct enable_hash_value { typedef std :: size_t type ; } ;

template < typename T > struct basic_numbers { } ;
template < typename T > struct long_numbers ;
template < typename T > struct ulong_numbers ;
template < typename T > struct float_numbers { } ;

template < > struct basic_numbers < bool > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < char > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < unsigned char > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < signed char > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < short > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < unsigned short > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < int > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < unsigned int > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < long > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct basic_numbers < unsigned long > :
boost :: hash_detail :: enable_hash_value { } ;


template < > struct basic_numbers < wchar_t > :
boost :: hash_detail :: enable_hash_value { } ;





template < typename T > struct long_numbers2 { } ;
template < typename T > struct ulong_numbers2 { } ;
template < typename T > struct long_numbers : long_numbers2 < T > { } ;
template < typename T > struct ulong_numbers : ulong_numbers2 < T > { } ;


template < > struct long_numbers < boost :: long_long_type > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct ulong_numbers < boost :: ulong_long_type > :
boost :: hash_detail :: enable_hash_value { } ;
#96
template < > struct float_numbers < float > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct float_numbers < double > :
boost :: hash_detail :: enable_hash_value { } ;
template < > struct float_numbers < long double > :
boost :: hash_detail :: enable_hash_value { } ;
}

template < typename T >
typename boost :: hash_detail :: basic_numbers < T > :: type hash_value ( T ) ;
template < typename T >
typename boost :: hash_detail :: long_numbers < T > :: type hash_value ( T ) ;
template < typename T >
typename boost :: hash_detail :: ulong_numbers < T > :: type hash_value ( T ) ;

template < typename T >
typename boost :: enable_if < boost :: is_enum < T > , std :: size_t > :: type
hash_value ( T ) ;


template < class T > std :: size_t hash_value ( T * const & ) ;





template < class T , unsigned N >
std :: size_t hash_value ( const T ( & x ) [ N ] ) ;

template < class T , unsigned N >
std :: size_t hash_value ( T ( & x ) [ N ] ) ;


template < class Ch , class A >
std :: size_t hash_value (
std :: basic_string < Ch , std :: char_traits < Ch > , A > const & ) ;

template < typename T >
typename boost :: hash_detail :: float_numbers < T > :: type hash_value ( T ) ;
#142
namespace hash_detail
{
template < class T >
inline std :: size_t hash_value_signed ( T val )
{
const int size_t_bits = std :: numeric_limits < std :: size_t > :: digits ;

const int length = ( std :: numeric_limits < T > :: digits - 1 )
/ size_t_bits ;

std :: size_t seed = 0 ;
T positive = val < 0 ? - 1 - val : val ;


for ( unsigned int i = length * size_t_bits ; i > 0 ; i -= size_t_bits )
{
seed ^= ( std :: size_t ) ( positive >> i ) + ( seed << 6 ) + ( seed >> 2 ) ;
}
seed ^= ( std :: size_t ) val + ( seed << 6 ) + ( seed >> 2 ) ;

return seed ;
}

template < class T >
inline std :: size_t hash_value_unsigned ( T val )
{
const int size_t_bits = std :: numeric_limits < std :: size_t > :: digits ;

const int length = ( std :: numeric_limits < T > :: digits - 1 )
/ size_t_bits ;

std :: size_t seed = 0 ;


for ( unsigned int i = length * size_t_bits ; i > 0 ; i -= size_t_bits )
{
seed ^= ( std :: size_t ) ( val >> i ) + ( seed << 6 ) + ( seed >> 2 ) ;
}
seed ^= ( std :: size_t ) val + ( seed << 6 ) + ( seed >> 2 ) ;

return seed ;
}
}

template < typename T >
typename boost :: hash_detail :: basic_numbers < T > :: type hash_value ( T v )
{
return static_cast < std :: size_t > ( v ) ;
}

template < typename T >
typename boost :: hash_detail :: long_numbers < T > :: type hash_value ( T v )
{
return hash_detail :: hash_value_signed ( v ) ;
}

template < typename T >
typename boost :: hash_detail :: ulong_numbers < T > :: type hash_value ( T v )
{
return hash_detail :: hash_value_unsigned ( v ) ;
}

template < typename T >
typename boost :: enable_if < boost :: is_enum < T > , std :: size_t > :: type
hash_value ( T v )
{
return static_cast < std :: size_t > ( v ) ;
}



template < class T > std :: size_t hash_value ( T * const & v )



{
#224
std :: size_t x = static_cast < std :: size_t > (
reinterpret_cast < std :: ptrdiff_t > ( v ) ) ;

return x + ( x >> 3 ) ;
}
#244
template < class T >
inline void hash_combine ( std :: size_t & seed , T const & v )

{
boost :: hash < T > hasher ;
seed ^= hasher ( v ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) ;
}





template < class It >
inline std :: size_t hash_range ( It first , It last )
{
std :: size_t seed = 0 ;

for ( ; first != last ; ++ first )
{
hash_combine ( seed , * first ) ;
}

return seed ;
}

template < class It >
inline void hash_range ( std :: size_t & seed , It first , It last )
{
for ( ; first != last ; ++ first )
{
hash_combine ( seed , * first ) ;
}
}
#305
template < class T , unsigned N >
inline std :: size_t hash_value ( const T ( & x ) [ N ] )
{
return hash_range ( x , x + N ) ;
}

template < class T , unsigned N >
inline std :: size_t hash_value ( T ( & x ) [ N ] )
{
return hash_range ( x , x + N ) ;
}


template < class Ch , class A >
inline std :: size_t hash_value (
std :: basic_string < Ch , std :: char_traits < Ch > , A > const & v )
{
return hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < typename T >
typename boost :: hash_detail :: float_numbers < T > :: type hash_value ( T v )
{
return boost :: hash_detail :: float_hash_value ( v ) ;
}
#414
template < > struct hash < bool > : public std :: unary_function < bool , std :: size_t > { std :: size_t operator ( ) (
#414
bool v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < char > : public std :: unary_function < char , std :: size_t > { std :: size_t operator ( ) (
#415
char v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < signed char > : public std :: unary_function < signed char , std :: size_t > { std :: size_t operator
#416
( ) ( signed char v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < unsigned char > : public std :: unary_function < unsigned char , std :: size_t > { std :: size_t
#417
operator ( ) ( unsigned char v ) const { return boost :: hash_value ( v ) ; } } ;

template < > struct hash < wchar_t > : public std :: unary_function < wchar_t , std :: size_t > { std :: size_t operator
#419
( ) ( wchar_t v ) const { return boost :: hash_value ( v ) ; } } ;

template < > struct hash < short > : public std :: unary_function < short , std :: size_t > { std :: size_t operator ( )
#421
( short v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < unsigned short > : public std :: unary_function < unsigned short , std :: size_t > { std :: size_t
#422
operator ( ) ( unsigned short v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < int > : public std :: unary_function < int , std :: size_t > { std :: size_t operator ( ) ( int
#423
v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < unsigned int > : public std :: unary_function < unsigned int , std :: size_t > { std :: size_t
#424
operator ( ) ( unsigned int v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < long > : public std :: unary_function < long , std :: size_t > { std :: size_t operator ( ) (
#425
long v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < unsigned long > : public std :: unary_function < unsigned long , std :: size_t > { std :: size_t
#426
operator ( ) ( unsigned long v ) const { return boost :: hash_value ( v ) ; } } ;

template < > struct hash < float > : public std :: unary_function < float , std :: size_t > { std :: size_t operator ( )
#428
( float v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < double > : public std :: unary_function < double , std :: size_t > { std :: size_t operator (
#429
) ( double v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < long double > : public std :: unary_function < long double , std :: size_t > { std :: size_t operator
#430
( ) ( long double v ) const { return boost :: hash_value ( v ) ; } } ;

template < > struct hash < std :: string > : public std :: unary_function < std :: string , std :: size_t > { std :: size_t
#432
operator ( ) ( std :: string const & v ) const { return boost :: hash_value ( v ) ; } } ;

template < > struct hash < std :: wstring > : public std :: unary_function < std :: wstring , std :: size_t > { std :: size_t
#434
operator ( ) ( std :: wstring const & v ) const { return boost :: hash_value ( v ) ; } } ;



template < > struct hash < boost :: long_long_type > : public std :: unary_function < boost :: long_long_type , std :: size_t
#438
> { std :: size_t operator ( ) ( boost :: long_long_type v ) const { return boost :: hash_value ( v ) ; } } ;
template < > struct hash < boost :: ulong_long_type > : public std :: unary_function < boost :: ulong_long_type , std ::
#439
size_t > { std :: size_t operator ( ) ( boost :: ulong_long_type v ) const { return boost :: hash_value ( v ) ; } } ;
#458
template < class T >
struct hash < T * >
: public std :: unary_function < T * , std :: size_t >
{
std :: size_t operator ( ) ( T * v ) const
{

return boost :: hash_value ( v ) ;
#472
}
} ;
#517
}
#1 "./boost/functional/hash/extensions.hpp"
#1 "./boost/functional/hash/hash.hpp"
#1 "./boost/detail/container_fwd.hpp"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/deque"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_deque.h"
#66
namespace std
{
#88
inline size_t
__deque_buf_size ( size_t __size )
{ return ( __size < 512
? size_t ( 512 / __size ) : size_t ( 1 ) ) ; }
#105
template < typename _Tp , typename _Ref , typename _Ptr >
struct _Deque_iterator
{
typedef _Deque_iterator < _Tp , _Tp & , _Tp * > iterator ;
typedef _Deque_iterator < _Tp , const _Tp & , const _Tp * > const_iterator ;

static size_t _S_buffer_size ( )
{ return __deque_buf_size ( sizeof ( _Tp ) ) ; }

typedef std :: random_access_iterator_tag iterator_category ;
typedef _Tp value_type ;
typedef _Ptr pointer ;
typedef _Ref reference ;
typedef size_t size_type ;
typedef ptrdiff_t difference_type ;
typedef _Tp * * _Map_pointer ;
typedef _Deque_iterator _Self ;

_Tp * _M_cur ;
_Tp * _M_first ;
_Tp * _M_last ;
_Map_pointer _M_node ;

_Deque_iterator ( _Tp * __x , _Map_pointer __y )
: _M_cur ( __x ) , _M_first ( * __y ) ,
_M_last ( * __y + _S_buffer_size ( ) ) , _M_node ( __y ) { }

_Deque_iterator ( )
: _M_cur ( 0 ) , _M_first ( 0 ) , _M_last ( 0 ) , _M_node ( 0 ) { }

_Deque_iterator ( const iterator & __x )
: _M_cur ( __x . _M_cur ) , _M_first ( __x . _M_first ) ,
_M_last ( __x . _M_last ) , _M_node ( __x . _M_node ) { }

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

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

_Self &
operator ++ ( )
{
++ _M_cur ;
if ( _M_cur == _M_last )
{
_M_set_node ( _M_node + 1 ) ;
_M_cur = _M_first ;
}
return * this ;
}

_Self
operator ++ ( int )
{
_Self __tmp = * this ;
++ * this ;
return __tmp ;
}

_Self &
operator -- ( )
{
if ( _M_cur == _M_first )
{
_M_set_node ( _M_node - 1 ) ;
_M_cur = _M_last ;
}
-- _M_cur ;
return * this ;
}

_Self
operator -- ( int )
{
_Self __tmp = * this ;
-- * this ;
return __tmp ;
}

_Self &
operator += ( difference_type __n )
{
const difference_type __offset = __n + ( _M_cur - _M_first ) ;
if ( __offset >= 0 && __offset < difference_type ( _S_buffer_size ( ) ) )
_M_cur += __n ;
else
{
const difference_type __node_offset =
__offset > 0 ? __offset / difference_type ( _S_buffer_size ( ) )
: - difference_type ( ( - __offset - 1 )
/ _S_buffer_size ( ) ) - 1 ;
_M_set_node ( _M_node + __node_offset ) ;
_M_cur = _M_first + ( __offset - __node_offset
* difference_type ( _S_buffer_size ( ) ) ) ;
}
return * this ;
}

_Self
operator + ( difference_type __n ) const
{
_Self __tmp = * this ;
return __tmp += __n ;
}

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

_Self
operator - ( difference_type __n ) const
{
_Self __tmp = * this ;
return __tmp -= __n ;
}

reference
operator [ ] ( difference_type __n ) const
{ return * ( * this + __n ) ; }
#233
void
_M_set_node ( _Map_pointer __new_node )
{
_M_node = __new_node ;
_M_first = * __new_node ;
_M_last = _M_first + difference_type ( _S_buffer_size ( ) ) ;
}
} ;




template < typename _Tp , typename _Ref , typename _Ptr >
inline bool
operator == ( const _Deque_iterator < _Tp , _Ref , _Ptr > & __x ,
const _Deque_iterator < _Tp , _Ref , _Ptr > & __y )
{ return __x . _M_cur == __y . _M_cur ; }

template < typename _Tp , typename _RefL , typename _PtrL ,
typename _RefR , typename _PtrR >
inline bool
operator == ( const _Deque_iterator < _Tp , _RefL , _PtrL > & __x ,
const _Deque_iterator < _Tp , _RefR , _PtrR > & __y )
{ return __x . _M_cur == __y . _M_cur ; }

template < typename _Tp , typename _Ref , typename _Ptr >
inline bool
operator != ( const _Deque_iterator < _Tp , _Ref , _Ptr > & __x ,
const _Deque_iterator < _Tp , _Ref , _Ptr > & __y )
{ return ! ( __x == __y ) ; }

template < typename _Tp , typename _RefL , typename _PtrL ,
typename _RefR , typename _PtrR >
inline bool
operator != ( const _Deque_iterator < _Tp , _RefL , _PtrL > & __x ,
const _Deque_iterator < _Tp , _RefR , _PtrR > & __y )
{ return ! ( __x == __y ) ; }

template < typename _Tp , typename _Ref , typename _Ptr >
inline bool
operator < ( const _Deque_iterator < _Tp , _Ref , _Ptr > & __x ,
const _Deque_iterator < _Tp , _Ref , _Ptr > & __y )
{ return ( __x . _M_node == __y . _M_node ) ? ( __x . _M_cur < __y . _M_cur )
: ( __x . _M_node < __y . _M_node ) ; }

template < typename _Tp , typename _RefL , typename _PtrL ,
typename _RefR , typename _PtrR >
inline bool
operator < ( const _Deque_iterator < _Tp , _RefL , _PtrL > & __x ,
const _Deque_iterator < _Tp , _RefR , _PtrR > & __y )
{ return ( __x . _M_node == __y . _M_node ) ? ( __x . _M_cur < __y . _M_cur )
: ( __x . _M_node < __y . _M_node ) ; }

template < typename _Tp , typename _Ref , typename _Ptr >
inline bool
operator > ( const _Deque_iterator < _Tp , _Ref , _Ptr > & __x ,
const _Deque_iterator < _Tp , _Ref , _Ptr > & __y )
{ return __y < __x ; }

template < typename _Tp , typename _RefL , typename _PtrL ,
typename _RefR , typename _PtrR >
inline bool
operator > ( const _Deque_iterator < _Tp , _RefL , _PtrL > & __x ,
const _Deque_iterator < _Tp , _RefR , _PtrR > & __y )
{ return __y < __x ; }

template < typename _Tp , typename _Ref , typename _Ptr >
inline bool
operator <= ( const _Deque_iterator < _Tp , _Ref , _Ptr > & __x ,
const _Deque_iterator < _Tp , _Ref , _Ptr > & __y )
{ return ! ( __y < __x ) ; }

template < typename _Tp , typename _RefL , typename _PtrL ,
typename _RefR , typename _PtrR >
inline bool
operator <= ( const _Deque_iterator < _Tp , _RefL , _PtrL > & __x ,
const _Deque_iterator < _Tp , _RefR , _PtrR > & __y )
{ return ! ( __y < __x ) ; }

template < typename _Tp , typename _Ref , typename _Ptr >
inline bool
operator >= ( const _Deque_iterator < _Tp , _Ref , _Ptr > & __x ,
const _Deque_iterator < _Tp , _Ref , _Ptr > & __y )
{ return ! ( __x < __y ) ; }

template < typename _Tp , typename _RefL , typename _PtrL ,
typename _RefR , typename _PtrR >
inline bool
operator >= ( const _Deque_iterator < _Tp , _RefL , _PtrL > & __x ,
const _Deque_iterator < _Tp , _RefR , _PtrR > & __y )
{ return ! ( __x < __y ) ; }





template < typename _Tp , typename _Ref , typename _Ptr >
inline typename _Deque_iterator < _Tp , _Ref , _Ptr > :: difference_type
operator - ( const _Deque_iterator < _Tp , _Ref , _Ptr > & __x ,
const _Deque_iterator < _Tp , _Ref , _Ptr > & __y )
{
return typename _Deque_iterator < _Tp , _Ref , _Ptr > :: difference_type
( _Deque_iterator < _Tp , _Ref , _Ptr > :: _S_buffer_size ( ) )
* ( __x . _M_node - __y . _M_node - 1 ) + ( __x . _M_cur - __x . _M_first )
+ ( __y . _M_last - __y . _M_cur ) ;
}

template < typename _Tp , typename _RefL , typename _PtrL ,
typename _RefR , typename _PtrR >
inline typename _Deque_iterator < _Tp , _RefL , _PtrL > :: difference_type
operator - ( const _Deque_iterator < _Tp , _RefL , _PtrL > & __x ,
const _Deque_iterator < _Tp , _RefR , _PtrR > & __y )
{
return typename _Deque_iterator < _Tp , _RefL , _PtrL > :: difference_type
( _Deque_iterator < _Tp , _RefL , _PtrL > :: _S_buffer_size ( ) )
* ( __x . _M_node - __y . _M_node - 1 ) + ( __x . _M_cur - __x . _M_first )
+ ( __y . _M_last - __y . _M_cur ) ;
}

template < typename _Tp , typename _Ref , typename _Ptr >
inline _Deque_iterator < _Tp , _Ref , _Ptr >
operator + ( ptrdiff_t __n , const _Deque_iterator < _Tp , _Ref , _Ptr > & __x )
{ return __x + __n ; }

template < typename _Tp >
void
fill ( const _Deque_iterator < _Tp , _Tp & , _Tp * > & ,
const _Deque_iterator < _Tp , _Tp & , _Tp * > & , const _Tp & ) ;

template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
copy ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , _Tp & , _Tp * > ) ;

template < typename _Tp >
inline _Deque_iterator < _Tp , _Tp & , _Tp * >
copy ( _Deque_iterator < _Tp , _Tp & , _Tp * > __first ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{ return std :: copy ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > ( __first ) ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > ( __last ) ,
__result ) ; }

template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
copy_backward ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , _Tp & , _Tp * > ) ;

template < typename _Tp >
inline _Deque_iterator < _Tp , _Tp & , _Tp * >
copy_backward ( _Deque_iterator < _Tp , _Tp & , _Tp * > __first ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{ return std :: copy_backward ( _Deque_iterator < _Tp ,
const _Tp & , const _Tp * > ( __first ) ,
_Deque_iterator < _Tp ,
const _Tp & , const _Tp * > ( __last ) ,
__result ) ; }


template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
move ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , _Tp & , _Tp * > ) ;

template < typename _Tp >
inline _Deque_iterator < _Tp , _Tp & , _Tp * >
move ( _Deque_iterator < _Tp , _Tp & , _Tp * > __first ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{ return std :: move ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > ( __first ) ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > ( __last ) ,
__result ) ; }

template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
move_backward ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > ,
_Deque_iterator < _Tp , _Tp & , _Tp * > ) ;

template < typename _Tp >
inline _Deque_iterator < _Tp , _Tp & , _Tp * >
move_backward ( _Deque_iterator < _Tp , _Tp & , _Tp * > __first ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{ return std :: move_backward ( _Deque_iterator < _Tp ,
const _Tp & , const _Tp * > ( __first ) ,
_Deque_iterator < _Tp ,
const _Tp & , const _Tp * > ( __last ) ,
__result ) ; }
#438
template < typename _Tp , typename _Alloc >
class _Deque_base
{
public :
typedef _Alloc allocator_type ;

allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_get_Tp_allocator ( ) ) ; }

typedef _Deque_iterator < _Tp , _Tp & , _Tp * > iterator ;
typedef _Deque_iterator < _Tp , const _Tp & , const _Tp * > const_iterator ;

_Deque_base ( )
: _M_impl ( )
{ _M_initialize_map ( 0 ) ; }

_Deque_base ( size_t __num_elements )
: _M_impl ( )
{ _M_initialize_map ( __num_elements ) ; }

_Deque_base ( const allocator_type & __a , size_t __num_elements )
: _M_impl ( __a )
{ _M_initialize_map ( __num_elements ) ; }

_Deque_base ( const allocator_type & __a )
: _M_impl ( __a )
{ }


_Deque_base ( _Deque_base && __x )
: _M_impl ( std :: move ( __x . _M_get_Tp_allocator ( ) ) )
{
_M_initialize_map ( 0 ) ;
if ( __x . _M_impl . _M_map )
{
std :: swap ( this -> _M_impl . _M_start , __x . _M_impl . _M_start ) ;
std :: swap ( this -> _M_impl . _M_finish , __x . _M_impl . _M_finish ) ;
std :: swap ( this -> _M_impl . _M_map , __x . _M_impl . _M_map ) ;
std :: swap ( this -> _M_impl . _M_map_size , __x . _M_impl . _M_map_size ) ;
}
}


~ _Deque_base ( ) ;

protected :



typedef typename _Alloc :: template rebind < _Tp * > :: other _Map_alloc_type ;

typedef typename _Alloc :: template rebind < _Tp > :: other _Tp_alloc_type ;

struct _Deque_impl
: public _Tp_alloc_type
{
_Tp * * _M_map ;
size_t _M_map_size ;
iterator _M_start ;
iterator _M_finish ;

_Deque_impl ( )
: _Tp_alloc_type ( ) , _M_map ( 0 ) , _M_map_size ( 0 ) ,
_M_start ( ) , _M_finish ( )
{ }

_Deque_impl ( const _Tp_alloc_type & __a )
: _Tp_alloc_type ( __a ) , _M_map ( 0 ) , _M_map_size ( 0 ) ,
_M_start ( ) , _M_finish ( )
{ }


_Deque_impl ( _Tp_alloc_type && __a )
: _Tp_alloc_type ( std :: move ( __a ) ) , _M_map ( 0 ) , _M_map_size ( 0 ) ,
_M_start ( ) , _M_finish ( )
{ }

} ;

_Tp_alloc_type &
_M_get_Tp_allocator ( ) noexcept
{ return * static_cast < _Tp_alloc_type * > ( & this -> _M_impl ) ; }

const _Tp_alloc_type &
_M_get_Tp_allocator ( ) const noexcept
{ return * static_cast < const _Tp_alloc_type * > ( & this -> _M_impl ) ; }

_Map_alloc_type
_M_get_map_allocator ( ) const noexcept
{ return _Map_alloc_type ( _M_get_Tp_allocator ( ) ) ; }

_Tp *
_M_allocate_node ( )
{
return _M_impl . _Tp_alloc_type :: allocate ( __deque_buf_size ( sizeof ( _Tp ) ) ) ;
}

void
_M_deallocate_node ( _Tp * __p )
{
_M_impl . _Tp_alloc_type :: deallocate ( __p , __deque_buf_size ( sizeof ( _Tp ) ) ) ;
}

_Tp * *
_M_allocate_map ( size_t __n )
{ return _M_get_map_allocator ( ) . allocate ( __n ) ; }

void
_M_deallocate_map ( _Tp * * __p , size_t __n )
{ _M_get_map_allocator ( ) . deallocate ( __p , __n ) ; }

protected :
void _M_initialize_map ( size_t ) ;
void _M_create_nodes ( _Tp * * __nstart , _Tp * * __nfinish ) ;
void _M_destroy_nodes ( _Tp * * __nstart , _Tp * * __nfinish ) ;
enum { _S_initial_map_size = 8 } ;

_Deque_impl _M_impl ;
} ;

template < typename _Tp , typename _Alloc >
_Deque_base < _Tp , _Alloc > ::
~ _Deque_base ( )
{
if ( this -> _M_impl . _M_map )
{
_M_destroy_nodes ( this -> _M_impl . _M_start . _M_node ,
this -> _M_impl . _M_finish . _M_node + 1 ) ;
_M_deallocate_map ( this -> _M_impl . _M_map , this -> _M_impl . _M_map_size ) ;
}
}
#579
template < typename _Tp , typename _Alloc >
void
_Deque_base < _Tp , _Alloc > ::
_M_initialize_map ( size_t __num_elements )
{
const size_t __num_nodes = ( __num_elements / __deque_buf_size ( sizeof ( _Tp ) )
+ 1 ) ;

this -> _M_impl . _M_map_size = std :: max ( ( size_t ) _S_initial_map_size ,
size_t ( __num_nodes + 2 ) ) ;
this -> _M_impl . _M_map = _M_allocate_map ( this -> _M_impl . _M_map_size ) ;
#596
_Tp * * __nstart = ( this -> _M_impl . _M_map
+ ( this -> _M_impl . _M_map_size - __num_nodes ) / 2 ) ;
_Tp * * __nfinish = __nstart + __num_nodes ;

try
{ _M_create_nodes ( __nstart , __nfinish ) ; }
catch ( ... )
{
_M_deallocate_map ( this -> _M_impl . _M_map , this -> _M_impl . _M_map_size ) ;
this -> _M_impl . _M_map = 0 ;
this -> _M_impl . _M_map_size = 0 ;
throw ;
}

this -> _M_impl . _M_start . _M_set_node ( __nstart ) ;
this -> _M_impl . _M_finish . _M_set_node ( __nfinish - 1 ) ;
this -> _M_impl . _M_start . _M_cur = _M_impl . _M_start . _M_first ;
this -> _M_impl . _M_finish . _M_cur = ( this -> _M_impl . _M_finish . _M_first
+ __num_elements
% __deque_buf_size ( sizeof ( _Tp ) ) ) ;
}

template < typename _Tp , typename _Alloc >
void
_Deque_base < _Tp , _Alloc > ::
_M_create_nodes ( _Tp * * __nstart , _Tp * * __nfinish )
{
_Tp * * __cur ;
try
{
for ( __cur = __nstart ; __cur < __nfinish ; ++ __cur )
* __cur = this -> _M_allocate_node ( ) ;
}
catch ( ... )
{
_M_destroy_nodes ( __nstart , __cur ) ;
throw ;
}
}

template < typename _Tp , typename _Alloc >
void
_Deque_base < _Tp , _Alloc > ::
_M_destroy_nodes ( _Tp * * __nstart , _Tp * * __nfinish )
{
for ( _Tp * * __n = __nstart ; __n < __nfinish ; ++ __n )
_M_deallocate_node ( * __n ) ;
}
#729
template < typename _Tp , typename _Alloc = std :: allocator < _Tp > >
class deque : protected _Deque_base < _Tp , _Alloc >
{

typedef typename _Alloc :: value_type _Alloc_value_type ;



typedef _Deque_base < _Tp , _Alloc > _Base ;
typedef typename _Base :: _Tp_alloc_type _Tp_alloc_type ;

public :
typedef _Tp value_type ;
typedef typename _Tp_alloc_type :: pointer pointer ;
typedef typename _Tp_alloc_type :: const_pointer const_pointer ;
typedef typename _Tp_alloc_type :: reference reference ;
typedef typename _Tp_alloc_type :: const_reference const_reference ;
typedef typename _Base :: iterator iterator ;
typedef typename _Base :: const_iterator const_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;
typedef std :: reverse_iterator < iterator > reverse_iterator ;
typedef size_t size_type ;
typedef ptrdiff_t difference_type ;
typedef _Alloc allocator_type ;

protected :
typedef pointer * _Map_pointer ;

static size_t _S_buffer_size ( )
{ return __deque_buf_size ( sizeof ( _Tp ) ) ; }


using _Base :: _M_initialize_map ;
using _Base :: _M_create_nodes ;
using _Base :: _M_destroy_nodes ;
using _Base :: _M_allocate_node ;
using _Base :: _M_deallocate_node ;
using _Base :: _M_allocate_map ;
using _Base :: _M_deallocate_map ;
using _Base :: _M_get_Tp_allocator ;





using _Base :: _M_impl ;

public :





deque ( )
: _Base ( ) { }





explicit
deque ( const allocator_type & __a )
: _Base ( __a , 0 ) { }
#801
explicit
deque ( size_type __n )
: _Base ( __n )
{ _M_default_initialize ( ) ; }
#814
deque ( size_type __n , const value_type & __value ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a , __n )
{ _M_fill_initialize ( __value ) ; }
#841
deque ( const deque & __x )
: _Base ( __x . _M_get_Tp_allocator ( ) , __x . size ( ) )
{ std :: __uninitialized_copy_a ( __x . begin ( ) , __x . end ( ) ,
this -> _M_impl . _M_start ,
_M_get_Tp_allocator ( ) ) ; }
#855
deque ( deque && __x )
: _Base ( std :: move ( __x ) ) { }
#869
deque ( initializer_list < value_type > __l ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a )
{
_M_range_initialize ( __l . begin ( ) , __l . end ( ) ,
random_access_iterator_tag ( ) ) ;
}
#894
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
deque ( _InputIterator __first , _InputIterator __last ,
const allocator_type & __a = allocator_type ( ) )
: _Base ( __a )
{ _M_initialize_dispatch ( __first , __last , __false_type ( ) ) ; }
#917
~ deque ( ) noexcept
{ _M_destroy_data ( begin ( ) , end ( ) , _M_get_Tp_allocator ( ) ) ; }
#927
deque &
operator = ( const deque & __x ) ;
#938
deque &
operator = ( deque && __x )
{


this -> clear ( ) ;
this -> swap ( __x ) ;
return * this ;
}
#959
deque &
operator = ( initializer_list < value_type > __l )
{
this -> assign ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}
#977
void
assign ( size_type __n , const value_type & __val )
{ _M_fill_assign ( __n , __val ) ; }
#994
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
void
assign ( _InputIterator __first , _InputIterator __last )
{ _M_assign_dispatch ( __first , __last , __false_type ( ) ) ; }
#1021
void
assign ( initializer_list < value_type > __l )
{ this -> assign ( __l . begin ( ) , __l . end ( ) ) ; }



allocator_type
get_allocator ( ) const noexcept
{ return _Base :: get_allocator ( ) ; }
#1036
iterator
begin ( ) noexcept
{ return this -> _M_impl . _M_start ; }





const_iterator
begin ( ) const noexcept
{ return this -> _M_impl . _M_start ; }
#1053
iterator
end ( ) noexcept
{ return this -> _M_impl . _M_finish ; }
#1062
const_iterator
end ( ) const noexcept
{ return this -> _M_impl . _M_finish ; }
#1071
reverse_iterator
rbegin ( ) noexcept
{ return reverse_iterator ( this -> _M_impl . _M_finish ) ; }
#1080
const_reverse_iterator
rbegin ( ) const noexcept
{ return const_reverse_iterator ( this -> _M_impl . _M_finish ) ; }
#1089
reverse_iterator
rend ( ) noexcept
{ return reverse_iterator ( this -> _M_impl . _M_start ) ; }
#1098
const_reverse_iterator
rend ( ) const noexcept
{ return const_reverse_iterator ( this -> _M_impl . _M_start ) ; }
#1107
const_iterator
cbegin ( ) const noexcept
{ return this -> _M_impl . _M_start ; }
#1116
const_iterator
cend ( ) const noexcept
{ return this -> _M_impl . _M_finish ; }
#1125
const_reverse_iterator
crbegin ( ) const noexcept
{ return const_reverse_iterator ( this -> _M_impl . _M_finish ) ; }
#1134
const_reverse_iterator
crend ( ) const noexcept
{ return const_reverse_iterator ( this -> _M_impl . _M_start ) ; }




size_type
size ( ) const noexcept
{ return this -> _M_impl . _M_finish - this -> _M_impl . _M_start ; }


size_type
max_size ( ) const noexcept
{ return _M_get_Tp_allocator ( ) . max_size ( ) ; }
#1160
void
resize ( size_type __new_size )
{
const size_type __len = size ( ) ;
if ( __new_size > __len )
_M_default_append ( __new_size - __len ) ;
else if ( __new_size < __len )
_M_erase_at_end ( this -> _M_impl . _M_start
+ difference_type ( __new_size ) ) ;
}
#1182
void
resize ( size_type __new_size , const value_type & __x )
{
const size_type __len = size ( ) ;
if ( __new_size > __len )
insert ( this -> _M_impl . _M_finish , __new_size - __len , __x ) ;
else if ( __new_size < __len )
_M_erase_at_end ( this -> _M_impl . _M_start
+ difference_type ( __new_size ) ) ;
}
#1218
void
shrink_to_fit ( )
{ _M_shrink_to_fit ( ) ; }
#1227
bool
empty ( ) const noexcept
{ return this -> _M_impl . _M_finish == this -> _M_impl . _M_start ; }
#1243
reference
operator [ ] ( size_type __n )
{ return this -> _M_impl . _M_start [ difference_type ( __n ) ] ; }
#1258
const_reference
operator [ ] ( size_type __n ) const
{ return this -> _M_impl . _M_start [ difference_type ( __n ) ] ; }

protected :

void
_M_range_check ( size_type __n ) const
{
if ( __n >= this -> size ( ) )
__throw_out_of_range ( ( "deque::_M_range_check" ) ) ;
}

public :
#1283
reference
at ( size_type __n )
{
_M_range_check ( __n ) ;
return ( * this ) [ __n ] ;
}
#1301
const_reference
at ( size_type __n ) const
{
_M_range_check ( __n ) ;
return ( * this ) [ __n ] ;
}





reference
front ( )
{ return * begin ( ) ; }





const_reference
front ( ) const
{ return * begin ( ) ; }





reference
back ( )
{
iterator __tmp = end ( ) ;
-- __tmp ;
return * __tmp ;
}





const_reference
back ( ) const
{
const_iterator __tmp = end ( ) ;
-- __tmp ;
return * __tmp ;
}
#1358
void
push_front ( const value_type & __x )
{
if ( this -> _M_impl . _M_start . _M_cur != this -> _M_impl . _M_start . _M_first )
{
this -> _M_impl . construct ( this -> _M_impl . _M_start . _M_cur - 1 , __x ) ;
-- this -> _M_impl . _M_start . _M_cur ;
}
else
_M_push_front_aux ( __x ) ;
}


void
push_front ( value_type && __x )
{ emplace_front ( std :: move ( __x ) ) ; }

template < typename ... _Args >
void
emplace_front ( _Args && ... __args ) ;
#1389
void
push_back ( const value_type & __x )
{
if ( this -> _M_impl . _M_finish . _M_cur
!= this -> _M_impl . _M_finish . _M_last - 1 )
{
this -> _M_impl . construct ( this -> _M_impl . _M_finish . _M_cur , __x ) ;
++ this -> _M_impl . _M_finish . _M_cur ;
}
else
_M_push_back_aux ( __x ) ;
}


void
push_back ( value_type && __x )
{ emplace_back ( std :: move ( __x ) ) ; }

template < typename ... _Args >
void
emplace_back ( _Args && ... __args ) ;
#1420
void
pop_front ( )
{
if ( this -> _M_impl . _M_start . _M_cur
!= this -> _M_impl . _M_start . _M_last - 1 )
{
this -> _M_impl . destroy ( this -> _M_impl . _M_start . _M_cur ) ;
++ this -> _M_impl . _M_start . _M_cur ;
}
else
_M_pop_front_aux ( ) ;
}
#1441
void
pop_back ( )
{
if ( this -> _M_impl . _M_finish . _M_cur
!= this -> _M_impl . _M_finish . _M_first )
{
-- this -> _M_impl . _M_finish . _M_cur ;
this -> _M_impl . destroy ( this -> _M_impl . _M_finish . _M_cur ) ;
}
else
_M_pop_back_aux ( ) ;
}
#1464
template < typename ... _Args >
iterator
emplace ( iterator __position , _Args && ... __args ) ;
#1478
iterator
insert ( iterator __position , const value_type & __x ) ;
#1491
iterator
insert ( iterator __position , value_type && __x )
{ return emplace ( __position , std :: move ( __x ) ) ; }
#1504
void
insert ( iterator __p , initializer_list < value_type > __l )
{ this -> insert ( __p , __l . begin ( ) , __l . end ( ) ) ; }
#1518
void
insert ( iterator __position , size_type __n , const value_type & __x )
{ _M_fill_insert ( __position , __n , __x ) ; }
#1533
template < typename _InputIterator ,
typename = std :: _RequireInputIter < _InputIterator >>
void
insert ( iterator __position , _InputIterator __first ,
_InputIterator __last )
{ _M_insert_dispatch ( __position , __first , __last , __false_type ( ) ) ; }
#1564
iterator
erase ( iterator __position ) ;
#1583
iterator
erase ( iterator __first , iterator __last ) ;
#1595
void
swap ( deque & __x )
{
std :: swap ( this -> _M_impl . _M_start , __x . _M_impl . _M_start ) ;
std :: swap ( this -> _M_impl . _M_finish , __x . _M_impl . _M_finish ) ;
std :: swap ( this -> _M_impl . _M_map , __x . _M_impl . _M_map ) ;
std :: swap ( this -> _M_impl . _M_map_size , __x . _M_impl . _M_map_size ) ;



std :: __alloc_swap < _Tp_alloc_type > :: _S_do_it ( _M_get_Tp_allocator ( ) ,
__x . _M_get_Tp_allocator ( ) ) ;
}
#1615
void
clear ( ) noexcept
{ _M_erase_at_end ( begin ( ) ) ; }

protected :
#1626
template < typename _Integer >
void
_M_initialize_dispatch ( _Integer __n , _Integer __x , __true_type )
{
_M_initialize_map ( static_cast < size_type > ( __n ) ) ;
_M_fill_initialize ( __x ) ;
}


template < typename _InputIterator >
void
_M_initialize_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type )
{
typedef typename std :: iterator_traits < _InputIterator > ::
iterator_category _IterCategory ;
_M_range_initialize ( __first , __last , _IterCategory ( ) ) ;
}
#1657
template < typename _InputIterator >
void
_M_range_initialize ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag ) ;


template < typename _ForwardIterator >
void
_M_range_initialize ( _ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag ) ;
#1679
void
_M_fill_initialize ( const value_type & __value ) ;



void
_M_default_initialize ( ) ;
#1695
template < typename _Integer >
void
_M_assign_dispatch ( _Integer __n , _Integer __val , __true_type )
{ _M_fill_assign ( __n , __val ) ; }


template < typename _InputIterator >
void
_M_assign_dispatch ( _InputIterator __first , _InputIterator __last ,
__false_type )
{
typedef typename std :: iterator_traits < _InputIterator > ::
iterator_category _IterCategory ;
_M_assign_aux ( __first , __last , _IterCategory ( ) ) ;
}


template < typename _InputIterator >
void
_M_assign_aux ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag ) ;


template < typename _ForwardIterator >
void
_M_assign_aux ( _ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag )
{
const size_type __len = std :: distance ( __first , __last ) ;
if ( __len > size ( ) )
{
_ForwardIterator __mid = __first ;
std :: advance ( __mid , size ( ) ) ;
std :: copy ( __first , __mid , begin ( ) ) ;
insert ( end ( ) , __mid , __last ) ;
}
else
_M_erase_at_end ( std :: copy ( __first , __last , begin ( ) ) ) ;
}



void
_M_fill_assign ( size_type __n , const value_type & __val )
{
if ( __n > size ( ) )
{
std :: fill ( begin ( ) , end ( ) , __val ) ;
insert ( end ( ) , __n - size ( ) , __val ) ;
}
else
{
_M_erase_at_end ( begin ( ) + difference_type ( __n ) ) ;
std :: fill ( begin ( ) , end ( ) , __val ) ;
}
}
#1759
template < typename ... _Args >
void _M_push_back_aux ( _Args && ... __args ) ;

template < typename ... _Args >
void _M_push_front_aux ( _Args && ... __args ) ;


void _M_pop_back_aux ( ) ;

void _M_pop_front_aux ( ) ;
#1778
template < typename _Integer >
void
_M_insert_dispatch ( iterator __pos ,
_Integer __n , _Integer __x , __true_type )
{ _M_fill_insert ( __pos , __n , __x ) ; }


template < typename _InputIterator >
void
_M_insert_dispatch ( iterator __pos ,
_InputIterator __first , _InputIterator __last ,
__false_type )
{
typedef typename std :: iterator_traits < _InputIterator > ::
iterator_category _IterCategory ;
_M_range_insert_aux ( __pos , __first , __last , _IterCategory ( ) ) ;
}


template < typename _InputIterator >
void
_M_range_insert_aux ( iterator __pos , _InputIterator __first ,
_InputIterator __last , std :: input_iterator_tag ) ;


template < typename _ForwardIterator >
void
_M_range_insert_aux ( iterator __pos , _ForwardIterator __first ,
_ForwardIterator __last , std :: forward_iterator_tag ) ;




void
_M_fill_insert ( iterator __pos , size_type __n , const value_type & __x ) ;
#1819
template < typename ... _Args >
iterator
_M_insert_aux ( iterator __pos , _Args && ... __args ) ;



void
_M_insert_aux ( iterator __pos , size_type __n , const value_type & __x ) ;


template < typename _ForwardIterator >
void
_M_insert_aux ( iterator __pos ,
_ForwardIterator __first , _ForwardIterator __last ,
size_type __n ) ;




void
_M_destroy_data_aux ( iterator __first , iterator __last ) ;



template < typename _Alloc1 >
void
_M_destroy_data ( iterator __first , iterator __last , const _Alloc1 & )
{ _M_destroy_data_aux ( __first , __last ) ; }

void
_M_destroy_data ( iterator __first , iterator __last ,
const std :: allocator < _Tp > & )
{
if ( ! __oracle_has_trivial_destructor ( value_type ) )
_M_destroy_data_aux ( __first , __last ) ;
}


void
_M_erase_at_begin ( iterator __pos )
{
_M_destroy_data ( begin ( ) , __pos , _M_get_Tp_allocator ( ) ) ;
_M_destroy_nodes ( this -> _M_impl . _M_start . _M_node , __pos . _M_node ) ;
this -> _M_impl . _M_start = __pos ;
}



void
_M_erase_at_end ( iterator __pos )
{
_M_destroy_data ( __pos , end ( ) , _M_get_Tp_allocator ( ) ) ;
_M_destroy_nodes ( __pos . _M_node + 1 ,
this -> _M_impl . _M_finish . _M_node + 1 ) ;
this -> _M_impl . _M_finish = __pos ;
}



void
_M_default_append ( size_type __n ) ;

bool
_M_shrink_to_fit ( ) ;




iterator
_M_reserve_elements_at_front ( size_type __n )
{
const size_type __vacancies = this -> _M_impl . _M_start . _M_cur
- this -> _M_impl . _M_start . _M_first ;
if ( __n > __vacancies )
_M_new_elements_at_front ( __n - __vacancies ) ;
return this -> _M_impl . _M_start - difference_type ( __n ) ;
}

iterator
_M_reserve_elements_at_back ( size_type __n )
{
const size_type __vacancies = ( this -> _M_impl . _M_finish . _M_last
- this -> _M_impl . _M_finish . _M_cur ) - 1 ;
if ( __n > __vacancies )
_M_new_elements_at_back ( __n - __vacancies ) ;
return this -> _M_impl . _M_finish + difference_type ( __n ) ;
}

void
_M_new_elements_at_front ( size_type __new_elements ) ;

void
_M_new_elements_at_back ( size_type __new_elements ) ;
#1923
void
_M_reserve_map_at_back ( size_type __nodes_to_add = 1 )
{
if ( __nodes_to_add + 1 > this -> _M_impl . _M_map_size
- ( this -> _M_impl . _M_finish . _M_node - this -> _M_impl . _M_map ) )
_M_reallocate_map ( __nodes_to_add , false ) ;
}

void
_M_reserve_map_at_front ( size_type __nodes_to_add = 1 )
{
if ( __nodes_to_add > size_type ( this -> _M_impl . _M_start . _M_node
- this -> _M_impl . _M_map ) )
_M_reallocate_map ( __nodes_to_add , true ) ;
}

void
_M_reallocate_map ( size_type __nodes_to_add , bool __add_at_front ) ;

} ;
#1955
template < typename _Tp , typename _Alloc >
inline bool
operator == ( const deque < _Tp , _Alloc > & __x ,
const deque < _Tp , _Alloc > & __y )
{ return __x . size ( ) == __y . size ( )
&& std :: equal ( __x . begin ( ) , __x . end ( ) , __y . begin ( ) ) ; }
#1973
template < typename _Tp , typename _Alloc >
inline bool
operator < ( const deque < _Tp , _Alloc > & __x ,
const deque < _Tp , _Alloc > & __y )
{ return std :: lexicographical_compare ( __x . begin ( ) , __x . end ( ) ,
__y . begin ( ) , __y . end ( ) ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator != ( const deque < _Tp , _Alloc > & __x ,
const deque < _Tp , _Alloc > & __y )
{ return ! ( __x == __y ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator > ( const deque < _Tp , _Alloc > & __x ,
const deque < _Tp , _Alloc > & __y )
{ return __y < __x ; }


template < typename _Tp , typename _Alloc >
inline bool
operator <= ( const deque < _Tp , _Alloc > & __x ,
const deque < _Tp , _Alloc > & __y )
{ return ! ( __y < __x ) ; }


template < typename _Tp , typename _Alloc >
inline bool
operator >= ( const deque < _Tp , _Alloc > & __x ,
const deque < _Tp , _Alloc > & __y )
{ return ! ( __x < __y ) ; }


template < typename _Tp , typename _Alloc >
inline void
swap ( deque < _Tp , _Alloc > & __x , deque < _Tp , _Alloc > & __y )
{ __x . swap ( __y ) ; }




}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/deque.tcc"
#59
namespace std
{



template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_default_initialize ( )
{
_Map_pointer __cur ;
try
{
for ( __cur = this -> _M_impl . _M_start . _M_node ;
__cur < this -> _M_impl . _M_finish . _M_node ;
++ __cur )
std :: __uninitialized_default_a ( * __cur , * __cur + _S_buffer_size ( ) ,
_M_get_Tp_allocator ( ) ) ;
std :: __uninitialized_default_a ( this -> _M_impl . _M_finish . _M_first ,
this -> _M_impl . _M_finish . _M_cur ,
_M_get_Tp_allocator ( ) ) ;
}
catch ( ... )
{
std :: _Destroy ( this -> _M_impl . _M_start , iterator ( * __cur , __cur ) ,
_M_get_Tp_allocator ( ) ) ;
throw ;
}
}


template < typename _Tp , typename _Alloc >
deque < _Tp , _Alloc > &
deque < _Tp , _Alloc > ::
operator = ( const deque & __x )
{
const size_type __len = size ( ) ;
if ( & __x != this )
{
if ( __len >= __x . size ( ) )
_M_erase_at_end ( std :: copy ( __x . begin ( ) , __x . end ( ) ,
this -> _M_impl . _M_start ) ) ;
else
{
const_iterator __mid = __x . begin ( ) + difference_type ( __len ) ;
std :: copy ( __x . begin ( ) , __mid , this -> _M_impl . _M_start ) ;
insert ( this -> _M_impl . _M_finish , __mid , __x . end ( ) ) ;
}
}
return * this ;
}


template < typename _Tp , typename _Alloc >
template < typename ... _Args >
void
deque < _Tp , _Alloc > ::
emplace_front ( _Args && ... __args )
{
if ( this -> _M_impl . _M_start . _M_cur != this -> _M_impl . _M_start . _M_first )
{
this -> _M_impl . construct ( this -> _M_impl . _M_start . _M_cur - 1 ,
std :: forward < _Args > ( __args ) ... ) ;
-- this -> _M_impl . _M_start . _M_cur ;
}
else
_M_push_front_aux ( std :: forward < _Args > ( __args ) ... ) ;
}

template < typename _Tp , typename _Alloc >
template < typename ... _Args >
void
deque < _Tp , _Alloc > ::
emplace_back ( _Args && ... __args )
{
if ( this -> _M_impl . _M_finish . _M_cur
!= this -> _M_impl . _M_finish . _M_last - 1 )
{
this -> _M_impl . construct ( this -> _M_impl . _M_finish . _M_cur ,
std :: forward < _Args > ( __args ) ... ) ;
++ this -> _M_impl . _M_finish . _M_cur ;
}
else
_M_push_back_aux ( std :: forward < _Args > ( __args ) ... ) ;
}


template < typename _Tp , typename _Alloc >
typename deque < _Tp , _Alloc > :: iterator
deque < _Tp , _Alloc > ::
insert ( iterator __position , const value_type & __x )
{
if ( __position . _M_cur == this -> _M_impl . _M_start . _M_cur )
{
push_front ( __x ) ;
return this -> _M_impl . _M_start ;
}
else if ( __position . _M_cur == this -> _M_impl . _M_finish . _M_cur )
{
push_back ( __x ) ;
iterator __tmp = this -> _M_impl . _M_finish ;
-- __tmp ;
return __tmp ;
}
else
return _M_insert_aux ( __position , __x ) ;
}


template < typename _Tp , typename _Alloc >
template < typename ... _Args >
typename deque < _Tp , _Alloc > :: iterator
deque < _Tp , _Alloc > ::
emplace ( iterator __position , _Args && ... __args )
{
if ( __position . _M_cur == this -> _M_impl . _M_start . _M_cur )
{
emplace_front ( std :: forward < _Args > ( __args ) ... ) ;
return this -> _M_impl . _M_start ;
}
else if ( __position . _M_cur == this -> _M_impl . _M_finish . _M_cur )
{
emplace_back ( std :: forward < _Args > ( __args ) ... ) ;
iterator __tmp = this -> _M_impl . _M_finish ;
-- __tmp ;
return __tmp ;
}
else
return _M_insert_aux ( __position , std :: forward < _Args > ( __args ) ... ) ;
}


template < typename _Tp , typename _Alloc >
typename deque < _Tp , _Alloc > :: iterator
deque < _Tp , _Alloc > ::
erase ( iterator __position )
{
iterator __next = __position ;
++ __next ;
const difference_type __index = __position - begin ( ) ;
if ( static_cast < size_type > ( __index ) < ( size ( ) >> 1 ) )
{
if ( __position != begin ( ) )
std :: move_backward ( begin ( ) , __position , __next ) ;
pop_front ( ) ;
}
else
{
if ( __next != end ( ) )
std :: move ( __next , end ( ) , __position ) ;
pop_back ( ) ;
}
return begin ( ) + __index ;
}

template < typename _Tp , typename _Alloc >
typename deque < _Tp , _Alloc > :: iterator
deque < _Tp , _Alloc > ::
erase ( iterator __first , iterator __last )
{
if ( __first == __last )
return __first ;
else if ( __first == begin ( ) && __last == end ( ) )
{
clear ( ) ;
return end ( ) ;
}
else
{
const difference_type __n = __last - __first ;
const difference_type __elems_before = __first - begin ( ) ;
if ( static_cast < size_type > ( __elems_before ) <= ( size ( ) - __n ) / 2 )
{
if ( __first != begin ( ) )
std :: move_backward ( begin ( ) , __first , __last ) ;
_M_erase_at_begin ( begin ( ) + __n ) ;
}
else
{
if ( __last != end ( ) )
std :: move ( __last , end ( ) , __first ) ;
_M_erase_at_end ( end ( ) - __n ) ;
}
return begin ( ) + __elems_before ;
}
}

template < typename _Tp , class _Alloc >
template < typename _InputIterator >
void
deque < _Tp , _Alloc > ::
_M_assign_aux ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag )
{
iterator __cur = begin ( ) ;
for ( ; __first != __last && __cur != end ( ) ; ++ __cur , ++ __first )
* __cur = * __first ;
if ( __first == __last )
_M_erase_at_end ( __cur ) ;
else
insert ( end ( ) , __first , __last ) ;
}

template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_fill_insert ( iterator __pos , size_type __n , const value_type & __x )
{
if ( __pos . _M_cur == this -> _M_impl . _M_start . _M_cur )
{
iterator __new_start = _M_reserve_elements_at_front ( __n ) ;
try
{
std :: __uninitialized_fill_a ( __new_start , this -> _M_impl . _M_start ,
__x , _M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_start = __new_start ;
}
catch ( ... )
{
_M_destroy_nodes ( __new_start . _M_node ,
this -> _M_impl . _M_start . _M_node ) ;
throw ;
}
}
else if ( __pos . _M_cur == this -> _M_impl . _M_finish . _M_cur )
{
iterator __new_finish = _M_reserve_elements_at_back ( __n ) ;
try
{
std :: __uninitialized_fill_a ( this -> _M_impl . _M_finish ,
__new_finish , __x ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __new_finish ;
}
catch ( ... )
{
_M_destroy_nodes ( this -> _M_impl . _M_finish . _M_node + 1 ,
__new_finish . _M_node + 1 ) ;
throw ;
}
}
else
_M_insert_aux ( __pos , __n , __x ) ;
}


template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_default_append ( size_type __n )
{
if ( __n )
{
iterator __new_finish = _M_reserve_elements_at_back ( __n ) ;
try
{
std :: __uninitialized_default_a ( this -> _M_impl . _M_finish ,
__new_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __new_finish ;
}
catch ( ... )
{
_M_destroy_nodes ( this -> _M_impl . _M_finish . _M_node + 1 ,
__new_finish . _M_node + 1 ) ;
throw ;
}
}
}

template < typename _Tp , typename _Alloc >
bool
deque < _Tp , _Alloc > ::
_M_shrink_to_fit ( )
{
const difference_type __front_capacity
= ( this -> _M_impl . _M_start . _M_cur - this -> _M_impl . _M_start . _M_first ) ;
if ( __front_capacity == 0 )
return false ;

const difference_type __back_capacity
= ( this -> _M_impl . _M_finish . _M_last - this -> _M_impl . _M_finish . _M_cur ) ;
if ( __front_capacity + __back_capacity < _S_buffer_size ( ) )
return false ;

return std :: __shrink_to_fit_aux < deque > :: _S_do_it ( * this ) ;
}


template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_fill_initialize ( const value_type & __value )
{
_Map_pointer __cur ;
try
{
for ( __cur = this -> _M_impl . _M_start . _M_node ;
__cur < this -> _M_impl . _M_finish . _M_node ;
++ __cur )
std :: __uninitialized_fill_a ( * __cur , * __cur + _S_buffer_size ( ) ,
__value , _M_get_Tp_allocator ( ) ) ;
std :: __uninitialized_fill_a ( this -> _M_impl . _M_finish . _M_first ,
this -> _M_impl . _M_finish . _M_cur ,
__value , _M_get_Tp_allocator ( ) ) ;
}
catch ( ... )
{
std :: _Destroy ( this -> _M_impl . _M_start , iterator ( * __cur , __cur ) ,
_M_get_Tp_allocator ( ) ) ;
throw ;
}
}

template < typename _Tp , typename _Alloc >
template < typename _InputIterator >
void
deque < _Tp , _Alloc > ::
_M_range_initialize ( _InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag )
{
this -> _M_initialize_map ( 0 ) ;
try
{
for ( ; __first != __last ; ++ __first )

emplace_back ( * __first ) ;



}
catch ( ... )
{
clear ( ) ;
throw ;
}
}

template < typename _Tp , typename _Alloc >
template < typename _ForwardIterator >
void
deque < _Tp , _Alloc > ::
_M_range_initialize ( _ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag )
{
const size_type __n = std :: distance ( __first , __last ) ;
this -> _M_initialize_map ( __n ) ;

_Map_pointer __cur_node ;
try
{
for ( __cur_node = this -> _M_impl . _M_start . _M_node ;
__cur_node < this -> _M_impl . _M_finish . _M_node ;
++ __cur_node )
{
_ForwardIterator __mid = __first ;
std :: advance ( __mid , _S_buffer_size ( ) ) ;
std :: __uninitialized_copy_a ( __first , __mid , * __cur_node ,
_M_get_Tp_allocator ( ) ) ;
__first = __mid ;
}
std :: __uninitialized_copy_a ( __first , __last ,
this -> _M_impl . _M_finish . _M_first ,
_M_get_Tp_allocator ( ) ) ;
}
catch ( ... )
{
std :: _Destroy ( this -> _M_impl . _M_start ,
iterator ( * __cur_node , __cur_node ) ,
_M_get_Tp_allocator ( ) ) ;
throw ;
}
}


template < typename _Tp , typename _Alloc >

template < typename ... _Args >
void
deque < _Tp , _Alloc > ::
_M_push_back_aux ( _Args && ... __args )





{
_M_reserve_map_at_back ( ) ;
* ( this -> _M_impl . _M_finish . _M_node + 1 ) = this -> _M_allocate_node ( ) ;
try
{

this -> _M_impl . construct ( this -> _M_impl . _M_finish . _M_cur ,
std :: forward < _Args > ( __args ) ... ) ;



this -> _M_impl . _M_finish . _M_set_node ( this -> _M_impl . _M_finish . _M_node
+ 1 ) ;
this -> _M_impl . _M_finish . _M_cur = this -> _M_impl . _M_finish . _M_first ;
}
catch ( ... )
{
_M_deallocate_node ( * ( this -> _M_impl . _M_finish . _M_node + 1 ) ) ;
throw ;
}
}


template < typename _Tp , typename _Alloc >

template < typename ... _Args >
void
deque < _Tp , _Alloc > ::
_M_push_front_aux ( _Args && ... __args )





{
_M_reserve_map_at_front ( ) ;
* ( this -> _M_impl . _M_start . _M_node - 1 ) = this -> _M_allocate_node ( ) ;
try
{
this -> _M_impl . _M_start . _M_set_node ( this -> _M_impl . _M_start . _M_node
- 1 ) ;
this -> _M_impl . _M_start . _M_cur = this -> _M_impl . _M_start . _M_last - 1 ;

this -> _M_impl . construct ( this -> _M_impl . _M_start . _M_cur ,
std :: forward < _Args > ( __args ) ... ) ;



}
catch ( ... )
{
++ this -> _M_impl . _M_start ;
_M_deallocate_node ( * ( this -> _M_impl . _M_start . _M_node - 1 ) ) ;
throw ;
}
}


template < typename _Tp , typename _Alloc >
void deque < _Tp , _Alloc > ::
_M_pop_back_aux ( )
{
_M_deallocate_node ( this -> _M_impl . _M_finish . _M_first ) ;
this -> _M_impl . _M_finish . _M_set_node ( this -> _M_impl . _M_finish . _M_node - 1 ) ;
this -> _M_impl . _M_finish . _M_cur = this -> _M_impl . _M_finish . _M_last - 1 ;
this -> _M_impl . destroy ( this -> _M_impl . _M_finish . _M_cur ) ;
}
#518
template < typename _Tp , typename _Alloc >
void deque < _Tp , _Alloc > ::
_M_pop_front_aux ( )
{
this -> _M_impl . destroy ( this -> _M_impl . _M_start . _M_cur ) ;
_M_deallocate_node ( this -> _M_impl . _M_start . _M_first ) ;
this -> _M_impl . _M_start . _M_set_node ( this -> _M_impl . _M_start . _M_node + 1 ) ;
this -> _M_impl . _M_start . _M_cur = this -> _M_impl . _M_start . _M_first ;
}

template < typename _Tp , typename _Alloc >
template < typename _InputIterator >
void
deque < _Tp , _Alloc > ::
_M_range_insert_aux ( iterator __pos ,
_InputIterator __first , _InputIterator __last ,
std :: input_iterator_tag )
{ std :: copy ( __first , __last , std :: inserter ( * this , __pos ) ) ; }

template < typename _Tp , typename _Alloc >
template < typename _ForwardIterator >
void
deque < _Tp , _Alloc > ::
_M_range_insert_aux ( iterator __pos ,
_ForwardIterator __first , _ForwardIterator __last ,
std :: forward_iterator_tag )
{
const size_type __n = std :: distance ( __first , __last ) ;
if ( __pos . _M_cur == this -> _M_impl . _M_start . _M_cur )
{
iterator __new_start = _M_reserve_elements_at_front ( __n ) ;
try
{
std :: __uninitialized_copy_a ( __first , __last , __new_start ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_start = __new_start ;
}
catch ( ... )
{
_M_destroy_nodes ( __new_start . _M_node ,
this -> _M_impl . _M_start . _M_node ) ;
throw ;
}
}
else if ( __pos . _M_cur == this -> _M_impl . _M_finish . _M_cur )
{
iterator __new_finish = _M_reserve_elements_at_back ( __n ) ;
try
{
std :: __uninitialized_copy_a ( __first , __last ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __new_finish ;
}
catch ( ... )
{
_M_destroy_nodes ( this -> _M_impl . _M_finish . _M_node + 1 ,
__new_finish . _M_node + 1 ) ;
throw ;
}
}
else
_M_insert_aux ( __pos , __first , __last , __n ) ;
}

template < typename _Tp , typename _Alloc >

template < typename ... _Args >
typename deque < _Tp , _Alloc > :: iterator
deque < _Tp , _Alloc > ::
_M_insert_aux ( iterator __pos , _Args && ... __args )
{
value_type __x_copy ( std :: forward < _Args > ( __args ) ... ) ;
#598
difference_type __index = __pos - this -> _M_impl . _M_start ;
if ( static_cast < size_type > ( __index ) < size ( ) / 2 )
{
push_front ( std :: move ( front ( ) ) ) ;
iterator __front1 = this -> _M_impl . _M_start ;
++ __front1 ;
iterator __front2 = __front1 ;
++ __front2 ;
__pos = this -> _M_impl . _M_start + __index ;
iterator __pos1 = __pos ;
++ __pos1 ;
std :: move ( __front2 , __pos1 , __front1 ) ;
}
else
{
push_back ( std :: move ( back ( ) ) ) ;
iterator __back1 = this -> _M_impl . _M_finish ;
-- __back1 ;
iterator __back2 = __back1 ;
-- __back2 ;
__pos = this -> _M_impl . _M_start + __index ;
std :: move_backward ( __pos , __back2 , __back1 ) ;
}
* __pos = std :: move ( __x_copy ) ;
return __pos ;
}

template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_insert_aux ( iterator __pos , size_type __n , const value_type & __x )
{
const difference_type __elems_before = __pos - this -> _M_impl . _M_start ;
const size_type __length = this -> size ( ) ;
value_type __x_copy = __x ;
if ( __elems_before < difference_type ( __length / 2 ) )
{
iterator __new_start = _M_reserve_elements_at_front ( __n ) ;
iterator __old_start = this -> _M_impl . _M_start ;
__pos = this -> _M_impl . _M_start + __elems_before ;
try
{
if ( __elems_before >= difference_type ( __n ) )
{
iterator __start_n = ( this -> _M_impl . _M_start
+ difference_type ( __n ) ) ;
std :: __uninitialized_move_a ( this -> _M_impl . _M_start ,
__start_n , __new_start ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_start = __new_start ;
std :: move ( __start_n , __pos , __old_start ) ;
std :: fill ( __pos - difference_type ( __n ) , __pos , __x_copy ) ;
}
else
{
std :: __uninitialized_move_fill ( this -> _M_impl . _M_start ,
__pos , __new_start ,
this -> _M_impl . _M_start ,
__x_copy ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_start = __new_start ;
std :: fill ( __old_start , __pos , __x_copy ) ;
}
}
catch ( ... )
{
_M_destroy_nodes ( __new_start . _M_node ,
this -> _M_impl . _M_start . _M_node ) ;
throw ;
}
}
else
{
iterator __new_finish = _M_reserve_elements_at_back ( __n ) ;
iterator __old_finish = this -> _M_impl . _M_finish ;
const difference_type __elems_after =
difference_type ( __length ) - __elems_before ;
__pos = this -> _M_impl . _M_finish - __elems_after ;
try
{
if ( __elems_after > difference_type ( __n ) )
{
iterator __finish_n = ( this -> _M_impl . _M_finish
- difference_type ( __n ) ) ;
std :: __uninitialized_move_a ( __finish_n ,
this -> _M_impl . _M_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __new_finish ;
std :: move_backward ( __pos , __finish_n , __old_finish ) ;
std :: fill ( __pos , __pos + difference_type ( __n ) , __x_copy ) ;
}
else
{
std :: __uninitialized_fill_move ( this -> _M_impl . _M_finish ,
__pos + difference_type ( __n ) ,
__x_copy , __pos ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __new_finish ;
std :: fill ( __pos , __old_finish , __x_copy ) ;
}
}
catch ( ... )
{
_M_destroy_nodes ( this -> _M_impl . _M_finish . _M_node + 1 ,
__new_finish . _M_node + 1 ) ;
throw ;
}
}
}

template < typename _Tp , typename _Alloc >
template < typename _ForwardIterator >
void
deque < _Tp , _Alloc > ::
_M_insert_aux ( iterator __pos ,
_ForwardIterator __first , _ForwardIterator __last ,
size_type __n )
{
const difference_type __elemsbefore = __pos - this -> _M_impl . _M_start ;
const size_type __length = size ( ) ;
if ( static_cast < size_type > ( __elemsbefore ) < __length / 2 )
{
iterator __new_start = _M_reserve_elements_at_front ( __n ) ;
iterator __old_start = this -> _M_impl . _M_start ;
__pos = this -> _M_impl . _M_start + __elemsbefore ;
try
{
if ( __elemsbefore >= difference_type ( __n ) )
{
iterator __start_n = ( this -> _M_impl . _M_start
+ difference_type ( __n ) ) ;
std :: __uninitialized_move_a ( this -> _M_impl . _M_start ,
__start_n , __new_start ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_start = __new_start ;
std :: move ( __start_n , __pos , __old_start ) ;
std :: copy ( __first , __last , __pos - difference_type ( __n ) ) ;
}
else
{
_ForwardIterator __mid = __first ;
std :: advance ( __mid , difference_type ( __n ) - __elemsbefore ) ;
std :: __uninitialized_move_copy ( this -> _M_impl . _M_start ,
__pos , __first , __mid ,
__new_start ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_start = __new_start ;
std :: copy ( __mid , __last , __old_start ) ;
}
}
catch ( ... )
{
_M_destroy_nodes ( __new_start . _M_node ,
this -> _M_impl . _M_start . _M_node ) ;
throw ;
}
}
else
{
iterator __new_finish = _M_reserve_elements_at_back ( __n ) ;
iterator __old_finish = this -> _M_impl . _M_finish ;
const difference_type __elemsafter =
difference_type ( __length ) - __elemsbefore ;
__pos = this -> _M_impl . _M_finish - __elemsafter ;
try
{
if ( __elemsafter > difference_type ( __n ) )
{
iterator __finish_n = ( this -> _M_impl . _M_finish
- difference_type ( __n ) ) ;
std :: __uninitialized_move_a ( __finish_n ,
this -> _M_impl . _M_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __new_finish ;
std :: move_backward ( __pos , __finish_n , __old_finish ) ;
std :: copy ( __first , __last , __pos ) ;
}
else
{
_ForwardIterator __mid = __first ;
std :: advance ( __mid , __elemsafter ) ;
std :: __uninitialized_copy_move ( __mid , __last , __pos ,
this -> _M_impl . _M_finish ,
this -> _M_impl . _M_finish ,
_M_get_Tp_allocator ( ) ) ;
this -> _M_impl . _M_finish = __new_finish ;
std :: copy ( __first , __mid , __pos ) ;
}
}
catch ( ... )
{
_M_destroy_nodes ( this -> _M_impl . _M_finish . _M_node + 1 ,
__new_finish . _M_node + 1 ) ;
throw ;
}
}
}

template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_destroy_data_aux ( iterator __first , iterator __last )
{
for ( _Map_pointer __node = __first . _M_node + 1 ;
__node < __last . _M_node ; ++ __node )
std :: _Destroy ( * __node , * __node + _S_buffer_size ( ) ,
_M_get_Tp_allocator ( ) ) ;

if ( __first . _M_node != __last . _M_node )
{
std :: _Destroy ( __first . _M_cur , __first . _M_last ,
_M_get_Tp_allocator ( ) ) ;
std :: _Destroy ( __last . _M_first , __last . _M_cur ,
_M_get_Tp_allocator ( ) ) ;
}
else
std :: _Destroy ( __first . _M_cur , __last . _M_cur ,
_M_get_Tp_allocator ( ) ) ;
}

template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_new_elements_at_front ( size_type __new_elems )
{
if ( this -> max_size ( ) - this -> size ( ) < __new_elems )
__throw_length_error ( ( "deque::_M_new_elements_at_front" ) ) ;

const size_type __new_nodes = ( ( __new_elems + _S_buffer_size ( ) - 1 )
/ _S_buffer_size ( ) ) ;
_M_reserve_map_at_front ( __new_nodes ) ;
size_type __i ;
try
{
for ( __i = 1 ; __i <= __new_nodes ; ++ __i )
* ( this -> _M_impl . _M_start . _M_node - __i ) = this -> _M_allocate_node ( ) ;
}
catch ( ... )
{
for ( size_type __j = 1 ; __j < __i ; ++ __j )
_M_deallocate_node ( * ( this -> _M_impl . _M_start . _M_node - __j ) ) ;
throw ;
}
}

template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_new_elements_at_back ( size_type __new_elems )
{
if ( this -> max_size ( ) - this -> size ( ) < __new_elems )
__throw_length_error ( ( "deque::_M_new_elements_at_back" ) ) ;

const size_type __new_nodes = ( ( __new_elems + _S_buffer_size ( ) - 1 )
/ _S_buffer_size ( ) ) ;
_M_reserve_map_at_back ( __new_nodes ) ;
size_type __i ;
try
{
for ( __i = 1 ; __i <= __new_nodes ; ++ __i )
* ( this -> _M_impl . _M_finish . _M_node + __i ) = this -> _M_allocate_node ( ) ;
}
catch ( ... )
{
for ( size_type __j = 1 ; __j < __i ; ++ __j )
_M_deallocate_node ( * ( this -> _M_impl . _M_finish . _M_node + __j ) ) ;
throw ;
}
}

template < typename _Tp , typename _Alloc >
void
deque < _Tp , _Alloc > ::
_M_reallocate_map ( size_type __nodes_to_add , bool __add_at_front )
{
const size_type __old_num_nodes
= this -> _M_impl . _M_finish . _M_node - this -> _M_impl . _M_start . _M_node + 1 ;
const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add ;

_Map_pointer __new_nstart ;
if ( this -> _M_impl . _M_map_size > 2 * __new_num_nodes )
{
__new_nstart = this -> _M_impl . _M_map + ( this -> _M_impl . _M_map_size
- __new_num_nodes ) / 2
+ ( __add_at_front ? __nodes_to_add : 0 ) ;
if ( __new_nstart < this -> _M_impl . _M_start . _M_node )
std :: copy ( this -> _M_impl . _M_start . _M_node ,
this -> _M_impl . _M_finish . _M_node + 1 ,
__new_nstart ) ;
else
std :: copy_backward ( this -> _M_impl . _M_start . _M_node ,
this -> _M_impl . _M_finish . _M_node + 1 ,
__new_nstart + __old_num_nodes ) ;
}
else
{
size_type __new_map_size = this -> _M_impl . _M_map_size
+ std :: max ( this -> _M_impl . _M_map_size ,
__nodes_to_add ) + 2 ;

_Map_pointer __new_map = this -> _M_allocate_map ( __new_map_size ) ;
__new_nstart = __new_map + ( __new_map_size - __new_num_nodes ) / 2
+ ( __add_at_front ? __nodes_to_add : 0 ) ;
std :: copy ( this -> _M_impl . _M_start . _M_node ,
this -> _M_impl . _M_finish . _M_node + 1 ,
__new_nstart ) ;
_M_deallocate_map ( this -> _M_impl . _M_map , this -> _M_impl . _M_map_size ) ;

this -> _M_impl . _M_map = __new_map ;
this -> _M_impl . _M_map_size = __new_map_size ;
}

this -> _M_impl . _M_start . _M_set_node ( __new_nstart ) ;
this -> _M_impl . _M_finish . _M_set_node ( __new_nstart + __old_num_nodes - 1 ) ;
}



template < typename _Tp >
void
fill ( const _Deque_iterator < _Tp , _Tp & , _Tp * > & __first ,
const _Deque_iterator < _Tp , _Tp & , _Tp * > & __last , const _Tp & __value )
{
typedef typename _Deque_iterator < _Tp , _Tp & , _Tp * > :: _Self _Self ;

for ( typename _Self :: _Map_pointer __node = __first . _M_node + 1 ;
__node < __last . _M_node ; ++ __node )
std :: fill ( * __node , * __node + _Self :: _S_buffer_size ( ) , __value ) ;

if ( __first . _M_node != __last . _M_node )
{
std :: fill ( __first . _M_cur , __first . _M_last , __value ) ;
std :: fill ( __last . _M_first , __last . _M_cur , __value ) ;
}
else
std :: fill ( __first . _M_cur , __last . _M_cur , __value ) ;
}

template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
copy ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > __first ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{
typedef typename _Deque_iterator < _Tp , _Tp & , _Tp * > :: _Self _Self ;
typedef typename _Self :: difference_type difference_type ;

difference_type __len = __last - __first ;
while ( __len > 0 )
{
const difference_type __clen
= std :: min ( __len , std :: min ( __first . _M_last - __first . _M_cur ,
__result . _M_last - __result . _M_cur ) ) ;
std :: copy ( __first . _M_cur , __first . _M_cur + __clen , __result . _M_cur ) ;
__first += __clen ;
__result += __clen ;
__len -= __clen ;
}
return __result ;
}

template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
copy_backward ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > __first ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{
typedef typename _Deque_iterator < _Tp , _Tp & , _Tp * > :: _Self _Self ;
typedef typename _Self :: difference_type difference_type ;

difference_type __len = __last - __first ;
while ( __len > 0 )
{
difference_type __llen = __last . _M_cur - __last . _M_first ;
_Tp * __lend = __last . _M_cur ;

difference_type __rlen = __result . _M_cur - __result . _M_first ;
_Tp * __rend = __result . _M_cur ;

if ( ! __llen )
{
__llen = _Self :: _S_buffer_size ( ) ;
__lend = * ( __last . _M_node - 1 ) + __llen ;
}
if ( ! __rlen )
{
__rlen = _Self :: _S_buffer_size ( ) ;
__rend = * ( __result . _M_node - 1 ) + __rlen ;
}

const difference_type __clen = std :: min ( __len ,
std :: min ( __llen , __rlen ) ) ;
std :: copy_backward ( __lend - __clen , __lend , __rend ) ;
__last -= __clen ;
__result -= __clen ;
__len -= __clen ;
}
return __result ;
}


template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
move ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > __first ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{
typedef typename _Deque_iterator < _Tp , _Tp & , _Tp * > :: _Self _Self ;
typedef typename _Self :: difference_type difference_type ;

difference_type __len = __last - __first ;
while ( __len > 0 )
{
const difference_type __clen
= std :: min ( __len , std :: min ( __first . _M_last - __first . _M_cur ,
__result . _M_last - __result . _M_cur ) ) ;
std :: move ( __first . _M_cur , __first . _M_cur + __clen , __result . _M_cur ) ;
__first += __clen ;
__result += __clen ;
__len -= __clen ;
}
return __result ;
}

template < typename _Tp >
_Deque_iterator < _Tp , _Tp & , _Tp * >
move_backward ( _Deque_iterator < _Tp , const _Tp & , const _Tp * > __first ,
_Deque_iterator < _Tp , const _Tp & , const _Tp * > __last ,
_Deque_iterator < _Tp , _Tp & , _Tp * > __result )
{
typedef typename _Deque_iterator < _Tp , _Tp & , _Tp * > :: _Self _Self ;
typedef typename _Self :: difference_type difference_type ;

difference_type __len = __last - __first ;
while ( __len > 0 )
{
difference_type __llen = __last . _M_cur - __last . _M_first ;
_Tp * __lend = __last . _M_cur ;

difference_type __rlen = __result . _M_cur - __result . _M_first ;
_Tp * __rend = __result . _M_cur ;

if ( ! __llen )
{
__llen = _Self :: _S_buffer_size ( ) ;
__lend = * ( __last . _M_node - 1 ) + __llen ;
}
if ( ! __rlen )
{
__rlen = _Self :: _S_buffer_size ( ) ;
__rend = * ( __result . _M_node - 1 ) + __rlen ;
}

const difference_type __clen = std :: min ( __len ,
std :: min ( __llen , __rlen ) ) ;
std :: move_backward ( __lend - __clen , __lend , __rend ) ;
__last -= __clen ;
__result -= __clen ;
__len -= __clen ;
}
return __result ;
}



}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/set"
#58
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_set.h"
#64
namespace std
{
#88
template < typename _Key , typename _Compare = std :: less < _Key > ,
typename _Alloc = std :: allocator < _Key > >
class set
{

typedef typename _Alloc :: value_type _Alloc_value_type ;





public :



typedef _Key key_type ;
typedef _Key value_type ;
typedef _Compare key_compare ;
typedef _Compare value_compare ;
typedef _Alloc allocator_type ;


private :
typedef typename _Alloc :: template rebind < _Key > :: other _Key_alloc_type ;

typedef _Rb_tree < key_type , value_type , _Identity < value_type > ,
key_compare , _Key_alloc_type > _Rep_type ;
_Rep_type _M_t ;

public :


typedef typename _Key_alloc_type :: pointer pointer ;
typedef typename _Key_alloc_type :: const_pointer const_pointer ;
typedef typename _Key_alloc_type :: reference reference ;
typedef typename _Key_alloc_type :: const_reference const_reference ;



typedef typename _Rep_type :: const_iterator iterator ;
typedef typename _Rep_type :: const_iterator const_iterator ;
typedef typename _Rep_type :: const_reverse_iterator reverse_iterator ;
typedef typename _Rep_type :: const_reverse_iterator const_reverse_iterator ;
typedef typename _Rep_type :: size_type size_type ;
typedef typename _Rep_type :: difference_type difference_type ;
#139
set ( )
: _M_t ( ) { }
#147
explicit
set ( const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Key_alloc_type ( __a ) ) { }
#162
template < typename _InputIterator >
set ( _InputIterator __first , _InputIterator __last )
: _M_t ( )
{ _M_t . _M_insert_unique ( __first , __last ) ; }
#179
template < typename _InputIterator >
set ( _InputIterator __first , _InputIterator __last ,
const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Key_alloc_type ( __a ) )
{ _M_t . _M_insert_unique ( __first , __last ) ; }
#193
set ( const set & __x )
: _M_t ( __x . _M_t ) { }
#204
set ( set && __x )
noexcept ( is_nothrow_copy_constructible < _Compare > :: value )
: _M_t ( std :: move ( __x . _M_t ) ) { }
#218
set ( initializer_list < value_type > __l ,
const _Compare & __comp = _Compare ( ) ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Key_alloc_type ( __a ) )
{ _M_t . _M_insert_unique ( __l . begin ( ) , __l . end ( ) ) ; }
#232
set &
operator = ( const set & __x )
{
_M_t = __x . _M_t ;
return * this ;
}
#247
set &
operator = ( set && __x )
{


this -> clear ( ) ;
this -> swap ( __x ) ;
return * this ;
}
#268
set &
operator = ( initializer_list < value_type > __l )
{
this -> clear ( ) ;
this -> insert ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}





key_compare
key_comp ( ) const
{ return _M_t . key_comp ( ) ; }

value_compare
value_comp ( ) const
{ return _M_t . key_comp ( ) ; }

allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_t . get_allocator ( ) ) ; }
#297
iterator
begin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#306
iterator
end ( ) const noexcept
{ return _M_t . end ( ) ; }
#315
reverse_iterator
rbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#324
reverse_iterator
rend ( ) const noexcept
{ return _M_t . rend ( ) ; }
#334
iterator
cbegin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#343
iterator
cend ( ) const noexcept
{ return _M_t . end ( ) ; }
#352
reverse_iterator
crbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#361
reverse_iterator
crend ( ) const noexcept
{ return _M_t . rend ( ) ; }



bool
empty ( ) const noexcept
{ return _M_t . empty ( ) ; }


size_type
size ( ) const noexcept
{ return _M_t . size ( ) ; }


size_type
max_size ( ) const noexcept
{ return _M_t . max_size ( ) ; }
#392
void
swap ( set & __x )
{ _M_t . swap ( __x . _M_t ) ; }
#411
template < typename ... _Args >
std :: pair < iterator , bool >
emplace ( _Args && ... __args )
{ return _M_t . _M_emplace_unique ( std :: forward < _Args > ( __args ) ... ) ; }
#437
template < typename ... _Args >
iterator
emplace_hint ( const_iterator __pos , _Args && ... __args )
{
return _M_t . _M_emplace_hint_unique ( __pos ,
std :: forward < _Args > ( __args ) ... ) ;
}
#459
std :: pair < iterator , bool >
insert ( const value_type & __x )
{
std :: pair < typename _Rep_type :: iterator , bool > __p =
_M_t . _M_insert_unique ( __x ) ;
return std :: pair < iterator , bool > ( __p . first , __p . second ) ;
}


std :: pair < iterator , bool >
insert ( value_type && __x )
{
std :: pair < typename _Rep_type :: iterator , bool > __p =
_M_t . _M_insert_unique ( std :: move ( __x ) ) ;
return std :: pair < iterator , bool > ( __p . first , __p . second ) ;
}
#496
iterator
insert ( const_iterator __position , const value_type & __x )
{ return _M_t . _M_insert_unique_ ( __position , __x ) ; }


iterator
insert ( const_iterator __position , value_type && __x )
{ return _M_t . _M_insert_unique_ ( __position , std :: move ( __x ) ) ; }
#515
template < typename _InputIterator >
void
insert ( _InputIterator __first , _InputIterator __last )
{ _M_t . _M_insert_unique ( __first , __last ) ; }
#528
void
insert ( initializer_list < value_type > __l )
{ this -> insert ( __l . begin ( ) , __l . end ( ) ) ; }
#549
__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( const_iterator __position )
{ return _M_t . erase ( __position ) ; }
#580
size_type
erase ( const key_type & __x )
{ return _M_t . erase ( __x ) ; }
#601
__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( const_iterator __first , const_iterator __last )
{ return _M_t . erase ( __first , __last ) ; }
#629
void
clear ( ) noexcept
{ _M_t . clear ( ) ; }
#643
size_type
count ( const key_type & __x ) const
{ return _M_t . find ( __x ) == _M_t . end ( ) ? 0 : 1 ; }
#661
iterator
find ( const key_type & __x )
{ return _M_t . find ( __x ) ; }

const_iterator
find ( const key_type & __x ) const
{ return _M_t . find ( __x ) ; }
#682
iterator
lower_bound ( const key_type & __x )
{ return _M_t . lower_bound ( __x ) ; }

const_iterator
lower_bound ( const key_type & __x ) const
{ return _M_t . lower_bound ( __x ) ; }
#698
iterator
upper_bound ( const key_type & __x )
{ return _M_t . upper_bound ( __x ) ; }

const_iterator
upper_bound ( const key_type & __x ) const
{ return _M_t . upper_bound ( __x ) ; }
#723
std :: pair < iterator , iterator >
equal_range ( const key_type & __x )
{ return _M_t . equal_range ( __x ) ; }

std :: pair < const_iterator , const_iterator >
equal_range ( const key_type & __x ) const
{ return _M_t . equal_range ( __x ) ; }


template < typename _K1 , typename _C1 , typename _A1 >
friend bool
operator == ( const set < _K1 , _C1 , _A1 > & , const set < _K1 , _C1 , _A1 > & ) ;

template < typename _K1 , typename _C1 , typename _A1 >
friend bool
operator < ( const set < _K1 , _C1 , _A1 > & , const set < _K1 , _C1 , _A1 > & ) ;
} ;
#752
template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator == ( const set < _Key , _Compare , _Alloc > & __x ,
const set < _Key , _Compare , _Alloc > & __y )
{ return __x . _M_t == __y . _M_t ; }
#769
template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator < ( const set < _Key , _Compare , _Alloc > & __x ,
const set < _Key , _Compare , _Alloc > & __y )
{ return __x . _M_t < __y . _M_t ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator != ( const set < _Key , _Compare , _Alloc > & __x ,
const set < _Key , _Compare , _Alloc > & __y )
{ return ! ( __x == __y ) ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator > ( const set < _Key , _Compare , _Alloc > & __x ,
const set < _Key , _Compare , _Alloc > & __y )
{ return __y < __x ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator <= ( const set < _Key , _Compare , _Alloc > & __x ,
const set < _Key , _Compare , _Alloc > & __y )
{ return ! ( __y < __x ) ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator >= ( const set < _Key , _Compare , _Alloc > & __x ,
const set < _Key , _Compare , _Alloc > & __y )
{ return ! ( __x < __y ) ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline void
swap ( set < _Key , _Compare , _Alloc > & __x , set < _Key , _Compare , _Alloc > & __y )
{ __x . swap ( __y ) ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/stl_multiset.h"
#64
namespace std
{
#90
template < typename _Key , typename _Compare = std :: less < _Key > ,
typename _Alloc = std :: allocator < _Key > >
class multiset
{

typedef typename _Alloc :: value_type _Alloc_value_type ;





public :

typedef _Key key_type ;
typedef _Key value_type ;
typedef _Compare key_compare ;
typedef _Compare value_compare ;
typedef _Alloc allocator_type ;

private :

typedef typename _Alloc :: template rebind < _Key > :: other _Key_alloc_type ;

typedef _Rb_tree < key_type , value_type , _Identity < value_type > ,
key_compare , _Key_alloc_type > _Rep_type ;

_Rep_type _M_t ;

public :
typedef typename _Key_alloc_type :: pointer pointer ;
typedef typename _Key_alloc_type :: const_pointer const_pointer ;
typedef typename _Key_alloc_type :: reference reference ;
typedef typename _Key_alloc_type :: const_reference const_reference ;



typedef typename _Rep_type :: const_iterator iterator ;
typedef typename _Rep_type :: const_iterator const_iterator ;
typedef typename _Rep_type :: const_reverse_iterator reverse_iterator ;
typedef typename _Rep_type :: const_reverse_iterator const_reverse_iterator ;
typedef typename _Rep_type :: size_type size_type ;
typedef typename _Rep_type :: difference_type difference_type ;





multiset ( )
: _M_t ( ) { }
#145
explicit
multiset ( const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Key_alloc_type ( __a ) ) { }
#159
template < typename _InputIterator >
multiset ( _InputIterator __first , _InputIterator __last )
: _M_t ( )
{ _M_t . _M_insert_equal ( __first , __last ) ; }
#175
template < typename _InputIterator >
multiset ( _InputIterator __first , _InputIterator __last ,
const _Compare & __comp ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Key_alloc_type ( __a ) )
{ _M_t . _M_insert_equal ( __first , __last ) ; }
#189
multiset ( const multiset & __x )
: _M_t ( __x . _M_t ) { }
#200
multiset ( multiset && __x )
noexcept ( is_nothrow_copy_constructible < _Compare > :: value )
: _M_t ( std :: move ( __x . _M_t ) ) { }
#214
multiset ( initializer_list < value_type > __l ,
const _Compare & __comp = _Compare ( ) ,
const allocator_type & __a = allocator_type ( ) )
: _M_t ( __comp , _Key_alloc_type ( __a ) )
{ _M_t . _M_insert_equal ( __l . begin ( ) , __l . end ( ) ) ; }
#228
multiset &
operator = ( const multiset & __x )
{
_M_t = __x . _M_t ;
return * this ;
}
#244
multiset &
operator = ( multiset && __x )
{


this -> clear ( ) ;
this -> swap ( __x ) ;
return * this ;
}
#265
multiset &
operator = ( initializer_list < value_type > __l )
{
this -> clear ( ) ;
this -> insert ( __l . begin ( ) , __l . end ( ) ) ;
return * this ;
}





key_compare
key_comp ( ) const
{ return _M_t . key_comp ( ) ; }

value_compare
value_comp ( ) const
{ return _M_t . key_comp ( ) ; }

allocator_type
get_allocator ( ) const noexcept
{ return allocator_type ( _M_t . get_allocator ( ) ) ; }
#294
iterator
begin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#303
iterator
end ( ) const noexcept
{ return _M_t . end ( ) ; }
#312
reverse_iterator
rbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#321
reverse_iterator
rend ( ) const noexcept
{ return _M_t . rend ( ) ; }
#331
iterator
cbegin ( ) const noexcept
{ return _M_t . begin ( ) ; }
#340
iterator
cend ( ) const noexcept
{ return _M_t . end ( ) ; }
#349
reverse_iterator
crbegin ( ) const noexcept
{ return _M_t . rbegin ( ) ; }
#358
reverse_iterator
crend ( ) const noexcept
{ return _M_t . rend ( ) ; }



bool
empty ( ) const noexcept
{ return _M_t . empty ( ) ; }


size_type
size ( ) const noexcept
{ return _M_t . size ( ) ; }


size_type
max_size ( ) const noexcept
{ return _M_t . max_size ( ) ; }
#389
void
swap ( multiset & __x )
{ _M_t . swap ( __x . _M_t ) ; }
#407
template < typename ... _Args >
iterator
emplace ( _Args && ... __args )
{ return _M_t . _M_emplace_equal ( std :: forward < _Args > ( __args ) ... ) ; }
#433
template < typename ... _Args >
iterator
emplace_hint ( const_iterator __pos , _Args && ... __args )
{
return _M_t . _M_emplace_hint_equal ( __pos ,
std :: forward < _Args > ( __args ) ... ) ;
}
#453
iterator
insert ( const value_type & __x )
{ return _M_t . _M_insert_equal ( __x ) ; }


iterator
insert ( value_type && __x )
{ return _M_t . _M_insert_equal ( std :: move ( __x ) ) ; }
#483
iterator
insert ( const_iterator __position , const value_type & __x )
{ return _M_t . _M_insert_equal_ ( __position , __x ) ; }


iterator
insert ( const_iterator __position , value_type && __x )
{ return _M_t . _M_insert_equal_ ( __position , std :: move ( __x ) ) ; }
#501
template < typename _InputIterator >
void
insert ( _InputIterator __first , _InputIterator __last )
{ _M_t . _M_insert_equal ( __first , __last ) ; }
#514
void
insert ( initializer_list < value_type > __l )
{ this -> insert ( __l . begin ( ) , __l . end ( ) ) ; }
#535
__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( const_iterator __position )
{ return _M_t . erase ( __position ) ; }
#566
size_type
erase ( const key_type & __x )
{ return _M_t . erase ( __x ) ; }
#587
__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
iterator
erase ( const_iterator __first , const_iterator __last )
{ return _M_t . erase ( __first , __last ) ; }
#615
void
clear ( ) noexcept
{ _M_t . clear ( ) ; }
#626
size_type
count ( const key_type & __x ) const
{ return _M_t . count ( __x ) ; }
#644
iterator
find ( const key_type & __x )
{ return _M_t . find ( __x ) ; }

const_iterator
find ( const key_type & __x ) const
{ return _M_t . find ( __x ) ; }
#665
iterator
lower_bound ( const key_type & __x )
{ return _M_t . lower_bound ( __x ) ; }

const_iterator
lower_bound ( const key_type & __x ) const
{ return _M_t . lower_bound ( __x ) ; }
#681
iterator
upper_bound ( const key_type & __x )
{ return _M_t . upper_bound ( __x ) ; }

const_iterator
upper_bound ( const key_type & __x ) const
{ return _M_t . upper_bound ( __x ) ; }
#706
std :: pair < iterator , iterator >
equal_range ( const key_type & __x )
{ return _M_t . equal_range ( __x ) ; }

std :: pair < const_iterator , const_iterator >
equal_range ( const key_type & __x ) const
{ return _M_t . equal_range ( __x ) ; }


template < typename _K1 , typename _C1 , typename _A1 >
friend bool
operator == ( const multiset < _K1 , _C1 , _A1 > & ,
const multiset < _K1 , _C1 , _A1 > & ) ;

template < typename _K1 , typename _C1 , typename _A1 >
friend bool
operator < ( const multiset < _K1 , _C1 , _A1 > & ,
const multiset < _K1 , _C1 , _A1 > & ) ;
} ;
#737
template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator == ( const multiset < _Key , _Compare , _Alloc > & __x ,
const multiset < _Key , _Compare , _Alloc > & __y )
{ return __x . _M_t == __y . _M_t ; }
#754
template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator < ( const multiset < _Key , _Compare , _Alloc > & __x ,
const multiset < _Key , _Compare , _Alloc > & __y )
{ return __x . _M_t < __y . _M_t ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator != ( const multiset < _Key , _Compare , _Alloc > & __x ,
const multiset < _Key , _Compare , _Alloc > & __y )
{ return ! ( __x == __y ) ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator > ( const multiset < _Key , _Compare , _Alloc > & __x ,
const multiset < _Key , _Compare , _Alloc > & __y )
{ return __y < __x ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator <= ( const multiset < _Key , _Compare , _Alloc > & __x ,
const multiset < _Key , _Compare , _Alloc > & __y )
{ return ! ( __y < __x ) ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline bool
operator >= ( const multiset < _Key , _Compare , _Alloc > & __x ,
const multiset < _Key , _Compare , _Alloc > & __y )
{ return ! ( __x < __y ) ; }


template < typename _Key , typename _Compare , typename _Alloc >
inline void
swap ( multiset < _Key , _Compare , _Alloc > & __x ,
multiset < _Key , _Compare , _Alloc > & __y )
{ __x . swap ( __y ) ; }


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bitset"
#45
#pragma GCC system_header
#60
namespace std
{
#70
template < size_t _Nw >
struct _Base_bitset
{
typedef unsigned long _WordT ;


_WordT _M_w [ _Nw ] ;

constexpr _Base_bitset ( ) noexcept
: _M_w ( ) { }


constexpr _Base_bitset ( unsigned long long __val ) noexcept
: _M_w { _WordT ( __val )



} { }
#94
static constexpr size_t
_S_whichword ( size_t __pos ) noexcept
{ return __pos / ( 8 * 8 ) ; }

static constexpr size_t
_S_whichbyte ( size_t __pos ) noexcept
{ return ( __pos % ( 8 * 8 ) ) / 8 ; }

static constexpr size_t
_S_whichbit ( size_t __pos ) noexcept
{ return __pos % ( 8 * 8 ) ; }

static constexpr _WordT
_S_maskbit ( size_t __pos ) noexcept
{ return ( static_cast < _WordT > ( 1 ) ) << _S_whichbit ( __pos ) ; }

_WordT &
_M_getword ( size_t __pos ) noexcept
{ return _M_w [ _S_whichword ( __pos ) ] ; }

constexpr _WordT
_M_getword ( size_t __pos ) const noexcept
{ return _M_w [ _S_whichword ( __pos ) ] ; }


const _WordT *
_M_getdata ( ) const noexcept
{ return _M_w ; }


_WordT &
_M_hiword ( ) noexcept
{ return _M_w [ _Nw - 1 ] ; }

constexpr _WordT
_M_hiword ( ) const noexcept
{ return _M_w [ _Nw - 1 ] ; }

void
_M_do_and ( const _Base_bitset < _Nw > & __x ) noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
_M_w [ __i ] &= __x . _M_w [ __i ] ;
}

void
_M_do_or ( const _Base_bitset < _Nw > & __x ) noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
_M_w [ __i ] |= __x . _M_w [ __i ] ;
}

void
_M_do_xor ( const _Base_bitset < _Nw > & __x ) noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
_M_w [ __i ] ^= __x . _M_w [ __i ] ;
}

void
_M_do_left_shift ( size_t __shift ) noexcept ;

void
_M_do_right_shift ( size_t __shift ) noexcept ;

void
_M_do_flip ( ) noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
_M_w [ __i ] = ~ _M_w [ __i ] ;
}

void
_M_do_set ( ) noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
_M_w [ __i ] = ~ static_cast < _WordT > ( 0 ) ;
}

void
_M_do_reset ( ) noexcept
{ __builtin_memset ( _M_w , 0 , _Nw * sizeof ( _WordT ) ) ; }

bool
_M_is_equal ( const _Base_bitset < _Nw > & __x ) const noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; ++ __i )
if ( _M_w [ __i ] != __x . _M_w [ __i ] )
return false ;
return true ;
}

template < size_t _Nb >
bool
_M_are_all ( ) const noexcept
{
for ( size_t __i = 0 ; __i < _Nw - 1 ; __i ++ )
if ( _M_w [ __i ] != ~ static_cast < _WordT > ( 0 ) )
return false ;
return _M_hiword ( ) == ( ~ static_cast < _WordT > ( 0 )
>> ( _Nw * ( 8 * 8 )
- _Nb ) ) ;
}

bool
_M_is_any ( ) const noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
if ( _M_w [ __i ] != static_cast < _WordT > ( 0 ) )
return true ;
return false ;
}

size_t
_M_do_count ( ) const noexcept
{
size_t __result = 0 ;
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
__result += __builtin_popcountl ( _M_w [ __i ] ) ;
return __result ;
}

unsigned long
_M_do_to_ulong ( ) const ;


unsigned long long
_M_do_to_ullong ( ) const ;



size_t
_M_do_find_first ( size_t ) const noexcept ;


size_t
_M_do_find_next ( size_t , size_t ) const noexcept ;
} ;


template < size_t _Nw >
void
_Base_bitset < _Nw > :: _M_do_left_shift ( size_t __shift ) noexcept
{
if ( __shift != 0 )
{
const size_t __wshift = __shift / ( 8 * 8 ) ;
const size_t __offset = __shift % ( 8 * 8 ) ;

if ( __offset == 0 )
for ( size_t __n = _Nw - 1 ; __n >= __wshift ; -- __n )
_M_w [ __n ] = _M_w [ __n - __wshift ] ;
else
{
const size_t __sub_offset = ( ( 8 * 8 )
- __offset ) ;
for ( size_t __n = _Nw - 1 ; __n > __wshift ; -- __n )
_M_w [ __n ] = ( ( _M_w [ __n - __wshift ] << __offset )
| ( _M_w [ __n - __wshift - 1 ] >> __sub_offset ) ) ;
_M_w [ __wshift ] = _M_w [ 0 ] << __offset ;
}

std :: fill ( _M_w + 0 , _M_w + __wshift , static_cast < _WordT > ( 0 ) ) ;
}
}

template < size_t _Nw >
void
_Base_bitset < _Nw > :: _M_do_right_shift ( size_t __shift ) noexcept
{
if ( __shift != 0 )
{
const size_t __wshift = __shift / ( 8 * 8 ) ;
const size_t __offset = __shift % ( 8 * 8 ) ;
const size_t __limit = _Nw - __wshift - 1 ;

if ( __offset == 0 )
for ( size_t __n = 0 ; __n <= __limit ; ++ __n )
_M_w [ __n ] = _M_w [ __n + __wshift ] ;
else
{
const size_t __sub_offset = ( ( 8 * 8 )
- __offset ) ;
for ( size_t __n = 0 ; __n < __limit ; ++ __n )
_M_w [ __n ] = ( ( _M_w [ __n + __wshift ] >> __offset )
| ( _M_w [ __n + __wshift + 1 ] << __sub_offset ) ) ;
_M_w [ __limit ] = _M_w [ _Nw - 1 ] >> __offset ;
}

std :: fill ( _M_w + __limit + 1 , _M_w + _Nw , static_cast < _WordT > ( 0 ) ) ;
}
}

template < size_t _Nw >
unsigned long
_Base_bitset < _Nw > :: _M_do_to_ulong ( ) const
{
for ( size_t __i = 1 ; __i < _Nw ; ++ __i )
if ( _M_w [ __i ] )
__throw_overflow_error ( ( "_Base_bitset::_M_do_to_ulong" ) ) ;
return _M_w [ 0 ] ;
}


template < size_t _Nw >
unsigned long long
_Base_bitset < _Nw > :: _M_do_to_ullong ( ) const
{
const bool __dw = sizeof ( unsigned long long ) > sizeof ( unsigned long ) ;
for ( size_t __i = 1 + __dw ; __i < _Nw ; ++ __i )
if ( _M_w [ __i ] )
__throw_overflow_error ( ( "_Base_bitset::_M_do_to_ullong" ) ) ;

if ( __dw )
return _M_w [ 0 ] + ( static_cast < unsigned long long > ( _M_w [ 1 ] )
<< ( 8 * 8 ) ) ;
return _M_w [ 0 ] ;
}


template < size_t _Nw >
size_t
_Base_bitset < _Nw > ::
_M_do_find_first ( size_t __not_found ) const noexcept
{
for ( size_t __i = 0 ; __i < _Nw ; __i ++ )
{
_WordT __thisword = _M_w [ __i ] ;
if ( __thisword != static_cast < _WordT > ( 0 ) )
return ( __i * ( 8 * 8 )
+ __builtin_ctzl ( __thisword ) ) ;
}

return __not_found ;
}

template < size_t _Nw >
size_t
_Base_bitset < _Nw > ::
_M_do_find_next ( size_t __prev , size_t __not_found ) const noexcept
{

++ __prev ;


if ( __prev >= _Nw * ( 8 * 8 ) )
return __not_found ;


size_t __i = _S_whichword ( __prev ) ;
_WordT __thisword = _M_w [ __i ] ;


__thisword &= ( ~ static_cast < _WordT > ( 0 ) ) << _S_whichbit ( __prev ) ;

if ( __thisword != static_cast < _WordT > ( 0 ) )
return ( __i * ( 8 * 8 )
+ __builtin_ctzl ( __thisword ) ) ;


__i ++ ;
for ( ; __i < _Nw ; __i ++ )
{
__thisword = _M_w [ __i ] ;
if ( __thisword != static_cast < _WordT > ( 0 ) )
return ( __i * ( 8 * 8 )
+ __builtin_ctzl ( __thisword ) ) ;
}

return __not_found ;
}
#371
template < >
struct _Base_bitset < 1 >
{
typedef unsigned long _WordT ;
_WordT _M_w ;

constexpr _Base_bitset ( ) noexcept
: _M_w ( 0 )
{ }


constexpr _Base_bitset ( unsigned long long __val ) noexcept



: _M_w ( __val )
{ }

static constexpr size_t
_S_whichword ( size_t __pos ) noexcept
{ return __pos / ( 8 * 8 ) ; }

static constexpr size_t
_S_whichbyte ( size_t __pos ) noexcept
{ return ( __pos % ( 8 * 8 ) ) / 8 ; }

static constexpr size_t
_S_whichbit ( size_t __pos ) noexcept
{ return __pos % ( 8 * 8 ) ; }

static constexpr _WordT
_S_maskbit ( size_t __pos ) noexcept
{ return ( static_cast < _WordT > ( 1 ) ) << _S_whichbit ( __pos ) ; }

_WordT &
_M_getword ( size_t ) noexcept
{ return _M_w ; }

constexpr _WordT
_M_getword ( size_t ) const noexcept
{ return _M_w ; }


const _WordT *
_M_getdata ( ) const noexcept
{ return & _M_w ; }


_WordT &
_M_hiword ( ) noexcept
{ return _M_w ; }

constexpr _WordT
_M_hiword ( ) const noexcept
{ return _M_w ; }

void
_M_do_and ( const _Base_bitset < 1 > & __x ) noexcept
{ _M_w &= __x . _M_w ; }

void
_M_do_or ( const _Base_bitset < 1 > & __x ) noexcept
{ _M_w |= __x . _M_w ; }

void
_M_do_xor ( const _Base_bitset < 1 > & __x ) noexcept
{ _M_w ^= __x . _M_w ; }

void
_M_do_left_shift ( size_t __shift ) noexcept
{ _M_w <<= __shift ; }

void
_M_do_right_shift ( size_t __shift ) noexcept
{ _M_w >>= __shift ; }

void
_M_do_flip ( ) noexcept
{ _M_w = ~ _M_w ; }

void
_M_do_set ( ) noexcept
{ _M_w = ~ static_cast < _WordT > ( 0 ) ; }

void
_M_do_reset ( ) noexcept
{ _M_w = 0 ; }

bool
_M_is_equal ( const _Base_bitset < 1 > & __x ) const noexcept
{ return _M_w == __x . _M_w ; }

template < size_t _Nb >
bool
_M_are_all ( ) const noexcept
{ return _M_w == ( ~ static_cast < _WordT > ( 0 )
>> ( ( 8 * 8 ) - _Nb ) ) ; }

bool
_M_is_any ( ) const noexcept
{ return _M_w != 0 ; }

size_t
_M_do_count ( ) const noexcept
{ return __builtin_popcountl ( _M_w ) ; }

unsigned long
_M_do_to_ulong ( ) const noexcept
{ return _M_w ; }


unsigned long long
_M_do_to_ullong ( ) const noexcept
{ return _M_w ; }


size_t
_M_do_find_first ( size_t __not_found ) const noexcept
{
if ( _M_w != 0 )
return __builtin_ctzl ( _M_w ) ;
else
return __not_found ;
}


size_t
_M_do_find_next ( size_t __prev , size_t __not_found ) const
noexcept
{
++ __prev ;
if ( __prev >= ( ( size_t ) ( 8 * 8 ) ) )
return __not_found ;

_WordT __x = _M_w >> __prev ;
if ( __x != 0 )
return __builtin_ctzl ( __x ) + __prev ;
else
return __not_found ;
}
} ;
#518
template < >
struct _Base_bitset < 0 >
{
typedef unsigned long _WordT ;

constexpr _Base_bitset ( ) noexcept
{ }


constexpr _Base_bitset ( unsigned long long ) noexcept



{ }

static constexpr size_t
_S_whichword ( size_t __pos ) noexcept
{ return __pos / ( 8 * 8 ) ; }

static constexpr size_t
_S_whichbyte ( size_t __pos ) noexcept
{ return ( __pos % ( 8 * 8 ) ) / 8 ; }

static constexpr size_t
_S_whichbit ( size_t __pos ) noexcept
{ return __pos % ( 8 * 8 ) ; }

static constexpr _WordT
_S_maskbit ( size_t __pos ) noexcept
{ return ( static_cast < _WordT > ( 1 ) ) << _S_whichbit ( __pos ) ; }
#556
_WordT &
_M_getword ( size_t ) noexcept
{
__throw_out_of_range ( ( "_Base_bitset::_M_getword" ) ) ;
return * new _WordT ;
}

constexpr _WordT
_M_getword ( size_t __pos ) const noexcept
{ return 0 ; }

constexpr _WordT
_M_hiword ( ) const noexcept
{ return 0 ; }

void
_M_do_and ( const _Base_bitset < 0 > & ) noexcept
{ }

void
_M_do_or ( const _Base_bitset < 0 > & ) noexcept
{ }

void
_M_do_xor ( const _Base_bitset < 0 > & ) noexcept
{ }

void
_M_do_left_shift ( size_t ) noexcept
{ }

void
_M_do_right_shift ( size_t ) noexcept
{ }

void
_M_do_flip ( ) noexcept
{ }

void
_M_do_set ( ) noexcept
{ }

void
_M_do_reset ( ) noexcept
{ }




bool
_M_is_equal ( const _Base_bitset < 0 > & ) const noexcept
{ return true ; }

template < size_t _Nb >
bool
_M_are_all ( ) const noexcept
{ return true ; }

bool
_M_is_any ( ) const noexcept
{ return false ; }

size_t
_M_do_count ( ) const noexcept
{ return 0 ; }

unsigned long
_M_do_to_ulong ( ) const noexcept
{ return 0 ; }


unsigned long long
_M_do_to_ullong ( ) const noexcept
{ return 0 ; }




size_t
_M_do_find_first ( size_t ) const noexcept
{ return 0 ; }

size_t
_M_do_find_next ( size_t , size_t ) const noexcept
{ return 0 ; }
} ;



template < size_t _Extrabits >
struct _Sanitize
{
typedef unsigned long _WordT ;

static void
_S_do_sanitize ( _WordT & __val ) noexcept
{ __val &= ~ ( ( ~ static_cast < _WordT > ( 0 ) ) << _Extrabits ) ; }
} ;

template < >
struct _Sanitize < 0 >
{
typedef unsigned long _WordT ;

static void
_S_do_sanitize ( _WordT ) noexcept { }
} ;


template < size_t _Nb , bool = _Nb < ( 8 * 8 ) >
struct _Sanitize_val
{
static constexpr unsigned long long
_S_do_sanitize_val ( unsigned long long __val )
{ return __val ; }
} ;

template < size_t _Nb >
struct _Sanitize_val < _Nb , true >
{
static constexpr unsigned long long
_S_do_sanitize_val ( unsigned long long __val )
{ return __val & ~ ( ( ~ static_cast < unsigned long long > ( 0 ) ) << _Nb ) ; }
} ;
#747
template < size_t _Nb >
class bitset
: private _Base_bitset < ( ( _Nb ) / ( 8 * 8 ) + ( ( _Nb ) % ( 8 * 8 ) == 0 ? 0 : 1 ) ) >
{
private :
typedef _Base_bitset < ( ( _Nb ) / ( 8 * 8 ) + ( ( _Nb ) % ( 8 * 8 ) == 0 ? 0 : 1 ) ) > _Base ;
typedef unsigned long _WordT ;

void
_M_do_sanitize ( ) noexcept
{
typedef _Sanitize < _Nb % ( 8 * 8 ) > __sanitize_type ;
__sanitize_type :: _S_do_sanitize ( this -> _M_hiword ( ) ) ;
}


template < typename > friend struct hash ;


public :
#779
class reference
{
friend class bitset ;

_WordT * _M_wp ;
size_t _M_bpos ;


reference ( ) ;

public :
reference ( bitset & __b , size_t __pos ) noexcept
{
_M_wp = & __b . _M_getword ( __pos ) ;
_M_bpos = _Base :: _S_whichbit ( __pos ) ;
}

~ reference ( ) noexcept
{ }


reference &
operator = ( bool __x ) noexcept
{
if ( __x )
* _M_wp |= _Base :: _S_maskbit ( _M_bpos ) ;
else
* _M_wp &= ~ _Base :: _S_maskbit ( _M_bpos ) ;
return * this ;
}


reference &
operator = ( const reference & __j ) noexcept
{
if ( ( * ( __j . _M_wp ) & _Base :: _S_maskbit ( __j . _M_bpos ) ) )
* _M_wp |= _Base :: _S_maskbit ( _M_bpos ) ;
else
* _M_wp &= ~ _Base :: _S_maskbit ( _M_bpos ) ;
return * this ;
}


bool
operator ~ ( ) const noexcept
{ return ( * ( _M_wp ) & _Base :: _S_maskbit ( _M_bpos ) ) == 0 ; }


operator bool ( ) const noexcept
{ return ( * ( _M_wp ) & _Base :: _S_maskbit ( _M_bpos ) ) != 0 ; }


reference &
flip ( ) noexcept
{
* _M_wp ^= _Base :: _S_maskbit ( _M_bpos ) ;
return * this ;
}
} ;
friend class reference ;



constexpr bitset ( ) noexcept
{ }



constexpr bitset ( unsigned long long __val ) noexcept
: _Base ( _Sanitize_val < _Nb > :: _S_do_sanitize_val ( __val ) ) { }
#864
template < class _CharT , class _Traits , class _Alloc >
explicit
bitset ( const std :: basic_string < _CharT , _Traits , _Alloc > & __s ,
size_t __position = 0 )
: _Base ( )
{
if ( __position > __s . size ( ) )
__throw_out_of_range (
( "bitset::bitset initial position " "not valid" ) ) ;
_M_copy_from_string ( __s , __position ,
std :: basic_string < _CharT , _Traits , _Alloc > :: npos ,
_CharT ( '0' ) , _CharT ( '1' ) ) ;
}
#888
template < class _CharT , class _Traits , class _Alloc >
bitset ( const std :: basic_string < _CharT , _Traits , _Alloc > & __s ,
size_t __position , size_t __n )
: _Base ( )
{
if ( __position > __s . size ( ) )
__throw_out_of_range (
( "bitset::bitset initial position " "not valid" ) ) ;
_M_copy_from_string ( __s , __position , __n , _CharT ( '0' ) , _CharT ( '1' ) ) ;
}



template < class _CharT , class _Traits , class _Alloc >
bitset ( const std :: basic_string < _CharT , _Traits , _Alloc > & __s ,
size_t __position , size_t __n ,
_CharT __zero , _CharT __one = _CharT ( '1' ) )
: _Base ( )
{
if ( __position > __s . size ( ) )
__throw_out_of_range (
( "bitset::bitset initial position " "not valid" ) ) ;
_M_copy_from_string ( __s , __position , __n , __zero , __one ) ;
}
#923
template < typename _CharT >
explicit
bitset ( const _CharT * __str ,
typename std :: basic_string < _CharT > :: size_type __n
= std :: basic_string < _CharT > :: npos ,
_CharT __zero = _CharT ( '0' ) , _CharT __one = _CharT ( '1' ) )
: _Base ( )
{
if ( ! __str )
__throw_logic_error ( ( "bitset::bitset(const _CharT*, ...)" ) ) ;

if ( __n == std :: basic_string < _CharT > :: npos )
__n = std :: char_traits < _CharT > :: length ( __str ) ;
_M_copy_from_ptr < _CharT , std :: char_traits < _CharT >> ( __str , __n , 0 ,
__n , __zero ,
__one ) ;
}
#950
bitset < _Nb > &
operator &= ( const bitset < _Nb > & __rhs ) noexcept
{
this -> _M_do_and ( __rhs ) ;
return * this ;
}

bitset < _Nb > &
operator |= ( const bitset < _Nb > & __rhs ) noexcept
{
this -> _M_do_or ( __rhs ) ;
return * this ;
}

bitset < _Nb > &
operator ^= ( const bitset < _Nb > & __rhs ) noexcept
{
this -> _M_do_xor ( __rhs ) ;
return * this ;
}
#979
bitset < _Nb > &
operator <<= ( size_t __position ) noexcept
{
if ( __position < _Nb )
{
this -> _M_do_left_shift ( __position ) ;
this -> _M_do_sanitize ( ) ;
}
else
this -> _M_do_reset ( ) ;
return * this ;
}

bitset < _Nb > &
operator >>= ( size_t __position ) noexcept
{
if ( __position < _Nb )
{
this -> _M_do_right_shift ( __position ) ;
this -> _M_do_sanitize ( ) ;
}
else
this -> _M_do_reset ( ) ;
return * this ;
}
#1012
bitset < _Nb > &
_Unchecked_set ( size_t __pos ) noexcept
{
this -> _M_getword ( __pos ) |= _Base :: _S_maskbit ( __pos ) ;
return * this ;
}

bitset < _Nb > &
_Unchecked_set ( size_t __pos , int __val ) noexcept
{
if ( __val )
this -> _M_getword ( __pos ) |= _Base :: _S_maskbit ( __pos ) ;
else
this -> _M_getword ( __pos ) &= ~ _Base :: _S_maskbit ( __pos ) ;
return * this ;
}

bitset < _Nb > &
_Unchecked_reset ( size_t __pos ) noexcept
{
this -> _M_getword ( __pos ) &= ~ _Base :: _S_maskbit ( __pos ) ;
return * this ;
}

bitset < _Nb > &
_Unchecked_flip ( size_t __pos ) noexcept
{
this -> _M_getword ( __pos ) ^= _Base :: _S_maskbit ( __pos ) ;
return * this ;
}

constexpr bool
_Unchecked_test ( size_t __pos ) const noexcept
{ return ( ( this -> _M_getword ( __pos ) & _Base :: _S_maskbit ( __pos ) )
!= static_cast < _WordT > ( 0 ) ) ; }
#1053
bitset < _Nb > &
set ( ) noexcept
{
this -> _M_do_set ( ) ;
this -> _M_do_sanitize ( ) ;
return * this ;
}
#1067
bitset < _Nb > &
set ( size_t __position , bool __val = true )
{
if ( __position >= _Nb )
__throw_out_of_range ( ( "bitset::set" ) ) ;
return _Unchecked_set ( __position , __val ) ;
}




bitset < _Nb > &
reset ( ) noexcept
{
this -> _M_do_reset ( ) ;
return * this ;
}
#1092
bitset < _Nb > &
reset ( size_t __position )
{
if ( __position >= _Nb )
__throw_out_of_range ( ( "bitset::reset" ) ) ;
return _Unchecked_reset ( __position ) ;
}




bitset < _Nb > &
flip ( ) noexcept
{
this -> _M_do_flip ( ) ;
this -> _M_do_sanitize ( ) ;
return * this ;
}
#1116
bitset < _Nb > &
flip ( size_t __position )
{
if ( __position >= _Nb )
__throw_out_of_range ( ( "bitset::flip" ) ) ;
return _Unchecked_flip ( __position ) ;
}


bitset < _Nb >
operator ~ ( ) const noexcept
{ return bitset < _Nb > ( * this ) . flip ( ) ; }
#1144
reference
operator [ ] ( size_t __position )
{ return reference ( * this , __position ) ; }

constexpr bool
operator [ ] ( size_t __position ) const
{ return _Unchecked_test ( __position ) ; }
#1159
unsigned long
to_ulong ( ) const
{ return this -> _M_do_to_ulong ( ) ; }


unsigned long long
to_ullong ( ) const
{ return this -> _M_do_to_ullong ( ) ; }
#1177
template < class _CharT , class _Traits , class _Alloc >
std :: basic_string < _CharT , _Traits , _Alloc >
to_string ( ) const
{
std :: basic_string < _CharT , _Traits , _Alloc > __result ;
_M_copy_to_string ( __result , _CharT ( '0' ) , _CharT ( '1' ) ) ;
return __result ;
}



template < class _CharT , class _Traits , class _Alloc >
std :: basic_string < _CharT , _Traits , _Alloc >
to_string ( _CharT __zero , _CharT __one = _CharT ( '1' ) ) const
{
std :: basic_string < _CharT , _Traits , _Alloc > __result ;
_M_copy_to_string ( __result , __zero , __one ) ;
return __result ;
}



template < class _CharT , class _Traits >
std :: basic_string < _CharT , _Traits , std :: allocator < _CharT > >
to_string ( ) const
{ return to_string < _CharT , _Traits , std :: allocator < _CharT > > ( ) ; }



template < class _CharT , class _Traits >
std :: basic_string < _CharT , _Traits , std :: allocator < _CharT > >
to_string ( _CharT __zero , _CharT __one = _CharT ( '1' ) ) const
{ return to_string < _CharT , _Traits ,
std :: allocator < _CharT > > ( __zero , __one ) ; }

template < class _CharT >
std :: basic_string < _CharT , std :: char_traits < _CharT > ,
std :: allocator < _CharT > >
to_string ( ) const
{
return to_string < _CharT , std :: char_traits < _CharT > ,
std :: allocator < _CharT > > ( ) ;
}

template < class _CharT >
std :: basic_string < _CharT , std :: char_traits < _CharT > ,
std :: allocator < _CharT > >
to_string ( _CharT __zero , _CharT __one = _CharT ( '1' ) ) const
{
return to_string < _CharT , std :: char_traits < _CharT > ,
std :: allocator < _CharT > > ( __zero , __one ) ;
}

std :: basic_string < char , std :: char_traits < char > , std :: allocator < char > >
to_string ( ) const
{
return to_string < char , std :: char_traits < char > ,
std :: allocator < char > > ( ) ;
}

std :: basic_string < char , std :: char_traits < char > , std :: allocator < char > >
to_string ( char __zero , char __one = '1' ) const
{
return to_string < char , std :: char_traits < char > ,
std :: allocator < char > > ( __zero , __one ) ;
}


template < class _CharT , class _Traits >
void
_M_copy_from_ptr ( const _CharT * , size_t , size_t , size_t ,
_CharT , _CharT ) ;

template < class _CharT , class _Traits , class _Alloc >
void
_M_copy_from_string ( const std :: basic_string < _CharT ,
_Traits , _Alloc > & __s , size_t __pos , size_t __n ,
_CharT __zero , _CharT __one )
{ _M_copy_from_ptr < _CharT , _Traits > ( __s . data ( ) , __s . size ( ) , __pos , __n ,
__zero , __one ) ; }

template < class _CharT , class _Traits , class _Alloc >
void
_M_copy_to_string ( std :: basic_string < _CharT , _Traits , _Alloc > & ,
_CharT , _CharT ) const ;


template < class _CharT , class _Traits , class _Alloc >
void
_M_copy_from_string ( const std :: basic_string < _CharT ,
_Traits , _Alloc > & __s , size_t __pos , size_t __n )
{ _M_copy_from_string ( __s , __pos , __n , _CharT ( '0' ) , _CharT ( '1' ) ) ; }

template < class _CharT , class _Traits , class _Alloc >
void
_M_copy_to_string ( std :: basic_string < _CharT , _Traits , _Alloc > & __s ) const
{ _M_copy_to_string ( __s , _CharT ( '0' ) , _CharT ( '1' ) ) ; }


size_t
count ( ) const noexcept
{ return this -> _M_do_count ( ) ; }


constexpr size_t
size ( ) const noexcept
{ return _Nb ; }



bool
operator == ( const bitset < _Nb > & __rhs ) const noexcept
{ return this -> _M_is_equal ( __rhs ) ; }

bool
operator != ( const bitset < _Nb > & __rhs ) const noexcept
{ return ! this -> _M_is_equal ( __rhs ) ; }
#1302
bool
test ( size_t __position ) const
{
if ( __position >= _Nb )
__throw_out_of_range ( ( "bitset::test" ) ) ;
return _Unchecked_test ( __position ) ;
}
#1316
bool
all ( ) const noexcept
{ return this -> template _M_are_all < _Nb > ( ) ; }





bool
any ( ) const noexcept
{ return this -> _M_is_any ( ) ; }





bool
none ( ) const noexcept
{ return ! this -> _M_is_any ( ) ; }



bitset < _Nb >
operator << ( size_t __position ) const noexcept
{ return bitset < _Nb > ( * this ) <<= __position ; }

bitset < _Nb >
operator >> ( size_t __position ) const noexcept
{ return bitset < _Nb > ( * this ) >>= __position ; }
#1353
size_t
_Find_first ( ) const noexcept
{ return this -> _M_do_find_first ( _Nb ) ; }
#1364
size_t
_Find_next ( size_t __prev ) const noexcept
{ return this -> _M_do_find_next ( __prev , _Nb ) ; }
} ;


template < size_t _Nb >
template < class _CharT , class _Traits >
void
bitset < _Nb > ::
_M_copy_from_ptr ( const _CharT * __s , size_t __len ,
size_t __pos , size_t __n , _CharT __zero , _CharT __one )
{
reset ( ) ;
const size_t __nbits = std :: min ( _Nb , std :: min ( __n , size_t ( __len - __pos ) ) ) ;
for ( size_t __i = __nbits ; __i > 0 ; -- __i )
{
const _CharT __c = __s [ __pos + __nbits - __i ] ;
if ( _Traits :: eq ( __c , __zero ) )
;
else if ( _Traits :: eq ( __c , __one ) )
_Unchecked_set ( __i - 1 ) ;
else
__throw_invalid_argument ( ( "bitset::_M_copy_from_ptr" ) ) ;
}
}

template < size_t _Nb >
template < class _CharT , class _Traits , class _Alloc >
void
bitset < _Nb > ::
_M_copy_to_string ( std :: basic_string < _CharT , _Traits , _Alloc > & __s ,
_CharT __zero , _CharT __one ) const
{
__s . assign ( _Nb , __zero ) ;
for ( size_t __i = _Nb ; __i > 0 ; -- __i )
if ( _Unchecked_test ( __i - 1 ) )
_Traits :: assign ( __s [ _Nb - __i ] , __one ) ;
}
#1414
template < size_t _Nb >
inline bitset < _Nb >
operator & ( const bitset < _Nb > & __x , const bitset < _Nb > & __y ) noexcept
{
bitset < _Nb > __result ( __x ) ;
__result &= __y ;
return __result ;
}

template < size_t _Nb >
inline bitset < _Nb >
operator | ( const bitset < _Nb > & __x , const bitset < _Nb > & __y ) noexcept
{
bitset < _Nb > __result ( __x ) ;
__result |= __y ;
return __result ;
}

template < size_t _Nb >
inline bitset < _Nb >
operator ^ ( const bitset < _Nb > & __x , const bitset < _Nb > & __y ) noexcept
{
bitset < _Nb > __result ( __x ) ;
__result ^= __y ;
return __result ;
}
#1451
template < class _CharT , class _Traits , size_t _Nb >
std :: basic_istream < _CharT , _Traits > &
operator >> ( std :: basic_istream < _CharT , _Traits > & __is , bitset < _Nb > & __x )
{
typedef typename _Traits :: char_type char_type ;
typedef std :: basic_istream < _CharT , _Traits > __istream_type ;
typedef typename __istream_type :: ios_base __ios_base ;

std :: basic_string < _CharT , _Traits > __tmp ;
__tmp . reserve ( _Nb ) ;



const char_type __zero = __is . widen ( '0' ) ;
const char_type __one = __is . widen ( '1' ) ;

typename __ios_base :: iostate __state = __ios_base :: goodbit ;
typename __istream_type :: sentry __sentry ( __is ) ;
if ( __sentry )
{
try
{
for ( size_t __i = _Nb ; __i > 0 ; -- __i )
{
static typename _Traits :: int_type __eof = _Traits :: eof ( ) ;

typename _Traits :: int_type __c1 = __is . rdbuf ( ) -> sbumpc ( ) ;
if ( _Traits :: eq_int_type ( __c1 , __eof ) )
{
__state |= __ios_base :: eofbit ;
break ;
}
else
{
const char_type __c2 = _Traits :: to_char_type ( __c1 ) ;
if ( _Traits :: eq ( __c2 , __zero ) )
__tmp . push_back ( __zero ) ;
else if ( _Traits :: eq ( __c2 , __one ) )
__tmp . push_back ( __one ) ;
else if ( _Traits ::
eq_int_type ( __is . rdbuf ( ) -> sputbackc ( __c2 ) ,
__eof ) )
{
__state |= __ios_base :: failbit ;
break ;
}
}
}
}
catch ( __cxxabiv1 :: __forced_unwind & )
{
__is . _M_setstate ( __ios_base :: badbit ) ;
throw ;
}
catch ( ... )
{ __is . _M_setstate ( __ios_base :: badbit ) ; }
}

if ( __tmp . empty ( ) && _Nb )
__state |= __ios_base :: failbit ;
else
__x . _M_copy_from_string ( __tmp , static_cast < size_t > ( 0 ) , _Nb ,
__zero , __one ) ;
if ( __state )
__is . setstate ( __state ) ;
return __is ;
}

template < class _CharT , class _Traits , size_t _Nb >
std :: basic_ostream < _CharT , _Traits > &
operator << ( std :: basic_ostream < _CharT , _Traits > & __os ,
const bitset < _Nb > & __x )
{
std :: basic_string < _CharT , _Traits > __tmp ;



const ctype < _CharT > & __ct = use_facet < ctype < _CharT > > ( __os . getloc ( ) ) ;
__x . _M_copy_to_string ( __tmp , __ct . widen ( '0' ) , __ct . widen ( '1' ) ) ;
return __os << __tmp ;
}



}
#1545
namespace std
{




template < size_t _Nb >
struct hash < std :: bitset < _Nb >>
: public __hash_base < size_t , std :: bitset < _Nb >>
{
size_t
operator ( ) ( const std :: bitset < _Nb > & __b ) const noexcept
{
const size_t __clength = ( _Nb + 8 - 1 ) / 8 ;
return std :: _Hash_impl :: hash ( __b . _M_getdata ( ) , __clength ) ;
}
} ;

template < >
struct hash < std :: bitset < 0 >>
: public __hash_base < size_t , std :: bitset < 0 >>
{
size_t
operator ( ) ( const std :: bitset < 0 > & ) const noexcept
{ return 0 ; }
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/complex"
#39
#pragma GCC system_header
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/sstream"
#36
#pragma GCC system_header
#41
namespace std
{
#63
template < typename _CharT , typename _Traits , typename _Alloc >
class basic_stringbuf : public basic_streambuf < _CharT , _Traits >
{
public :

typedef _CharT char_type ;
typedef _Traits traits_type ;


typedef _Alloc allocator_type ;
typedef typename traits_type :: int_type int_type ;
typedef typename traits_type :: pos_type pos_type ;
typedef typename traits_type :: off_type off_type ;

typedef basic_streambuf < char_type , traits_type > __streambuf_type ;
typedef basic_string < char_type , _Traits , _Alloc > __string_type ;
typedef typename __string_type :: size_type __size_type ;

protected :

ios_base :: openmode _M_mode ;


__string_type _M_string ;

public :
#97
explicit
basic_stringbuf ( ios_base :: openmode __mode = ios_base :: in | ios_base :: out )
: __streambuf_type ( ) , _M_mode ( __mode ) , _M_string ( )
{ }
#110
explicit
basic_stringbuf ( const __string_type & __str ,
ios_base :: openmode __mode = ios_base :: in | ios_base :: out )
: __streambuf_type ( ) , _M_mode ( ) , _M_string ( __str . data ( ) , __str . size ( ) )
{ _M_stringbuf_init ( __mode ) ; }
#125
__string_type
str ( ) const
{
__string_type __ret ;
if ( this -> pptr ( ) )
{

if ( this -> pptr ( ) > this -> egptr ( ) )
__ret = __string_type ( this -> pbase ( ) , this -> pptr ( ) ) ;
else
__ret = __string_type ( this -> pbase ( ) , this -> egptr ( ) ) ;
}
else
__ret = _M_string ;
return __ret ;
}
#149
void
str ( const __string_type & __s )
{

_M_string . assign ( __s . data ( ) , __s . size ( ) ) ;
_M_stringbuf_init ( _M_mode ) ;
}

protected :

void
_M_stringbuf_init ( ios_base :: openmode __mode )
{
_M_mode = __mode ;
__size_type __len = 0 ;
if ( _M_mode & ( ios_base :: ate | ios_base :: app ) )
__len = _M_string . size ( ) ;
_M_sync ( const_cast < char_type * > ( _M_string . data ( ) ) , 0 , __len ) ;
}

virtual streamsize
showmanyc ( )
{
streamsize __ret = - 1 ;
if ( _M_mode & ios_base :: in )
{
_M_update_egptr ( ) ;
__ret = this -> egptr ( ) - this -> gptr ( ) ;
}
return __ret ;
}

virtual int_type
underflow ( ) ;

virtual int_type
pbackfail ( int_type __c = traits_type :: eof ( ) ) ;

virtual int_type
overflow ( int_type __c = traits_type :: eof ( ) ) ;
#201
virtual __streambuf_type *
setbuf ( char_type * __s , streamsize __n )
{
if ( __s && __n >= 0 )
{
#212
_M_string . clear ( ) ;


_M_sync ( __s , __n , 0 ) ;
}
return this ;
}

virtual pos_type
seekoff ( off_type __off , ios_base :: seekdir __way ,
ios_base :: openmode __mode = ios_base :: in | ios_base :: out ) ;

virtual pos_type
seekpos ( pos_type __sp ,
ios_base :: openmode __mode = ios_base :: in | ios_base :: out ) ;




void
_M_sync ( char_type * __base , __size_type __i , __size_type __o ) ;



void
_M_update_egptr ( )
{
const bool __testin = _M_mode & ios_base :: in ;
if ( this -> pptr ( ) && this -> pptr ( ) > this -> egptr ( ) )
{
if ( __testin )
this -> setg ( this -> eback ( ) , this -> gptr ( ) , this -> pptr ( ) ) ;
else
this -> setg ( this -> pptr ( ) , this -> pptr ( ) , this -> pptr ( ) ) ;
}
}



void
_M_pbump ( char_type * __pbeg , char_type * __pend , off_type __off ) ;
} ;
#271
template < typename _CharT , typename _Traits , typename _Alloc >
class basic_istringstream : public basic_istream < _CharT , _Traits >
{
public :

typedef _CharT char_type ;
typedef _Traits traits_type ;


typedef _Alloc allocator_type ;
typedef typename traits_type :: int_type int_type ;
typedef typename traits_type :: pos_type pos_type ;
typedef typename traits_type :: off_type off_type ;


typedef basic_string < _CharT , _Traits , _Alloc > __string_type ;
typedef basic_stringbuf < _CharT , _Traits , _Alloc > __stringbuf_type ;
typedef basic_istream < char_type , traits_type > __istream_type ;

private :
__stringbuf_type _M_stringbuf ;

public :
#307
explicit
basic_istringstream ( ios_base :: openmode __mode = ios_base :: in )
: __istream_type ( ) , _M_stringbuf ( __mode | ios_base :: in )
{ this -> init ( & _M_stringbuf ) ; }
#325
explicit
basic_istringstream ( const __string_type & __str ,
ios_base :: openmode __mode = ios_base :: in )
: __istream_type ( ) , _M_stringbuf ( __str , __mode | ios_base :: in )
{ this -> init ( & _M_stringbuf ) ; }
#337
~ basic_istringstream ( )
{ }
#347
__stringbuf_type *
rdbuf ( ) const
{ return const_cast < __stringbuf_type * > ( & _M_stringbuf ) ; }





__string_type
str ( ) const
{ return _M_stringbuf . str ( ) ; }
#365
void
str ( const __string_type & __s )
{ _M_stringbuf . str ( __s ) ; }
} ;
#386
template < typename _CharT , typename _Traits , typename _Alloc >
class basic_ostringstream : public basic_ostream < _CharT , _Traits >
{
public :

typedef _CharT char_type ;
typedef _Traits traits_type ;


typedef _Alloc allocator_type ;
typedef typename traits_type :: int_type int_type ;
typedef typename traits_type :: pos_type pos_type ;
typedef typename traits_type :: off_type off_type ;


typedef basic_string < _CharT , _Traits , _Alloc > __string_type ;
typedef basic_stringbuf < _CharT , _Traits , _Alloc > __stringbuf_type ;
typedef basic_ostream < char_type , traits_type > __ostream_type ;

private :
__stringbuf_type _M_stringbuf ;

public :
#422
explicit
basic_ostringstream ( ios_base :: openmode __mode = ios_base :: out )
: __ostream_type ( ) , _M_stringbuf ( __mode | ios_base :: out )
{ this -> init ( & _M_stringbuf ) ; }
#440
explicit
basic_ostringstream ( const __string_type & __str ,
ios_base :: openmode __mode = ios_base :: out )
: __ostream_type ( ) , _M_stringbuf ( __str , __mode | ios_base :: out )
{ this -> init ( & _M_stringbuf ) ; }
#452
~ basic_ostringstream ( )
{ }
#462
__stringbuf_type *
rdbuf ( ) const
{ return const_cast < __stringbuf_type * > ( & _M_stringbuf ) ; }





__string_type
str ( ) const
{ return _M_stringbuf . str ( ) ; }
#480
void
str ( const __string_type & __s )
{ _M_stringbuf . str ( __s ) ; }
} ;
#501
template < typename _CharT , typename _Traits , typename _Alloc >
class basic_stringstream : public basic_iostream < _CharT , _Traits >
{
public :

typedef _CharT char_type ;
typedef _Traits traits_type ;


typedef _Alloc allocator_type ;
typedef typename traits_type :: int_type int_type ;
typedef typename traits_type :: pos_type pos_type ;
typedef typename traits_type :: off_type off_type ;


typedef basic_string < _CharT , _Traits , _Alloc > __string_type ;
typedef basic_stringbuf < _CharT , _Traits , _Alloc > __stringbuf_type ;
typedef basic_iostream < char_type , traits_type > __iostream_type ;

private :
__stringbuf_type _M_stringbuf ;

public :
#536
explicit
basic_stringstream ( ios_base :: openmode __m = ios_base :: out | ios_base :: in )
: __iostream_type ( ) , _M_stringbuf ( __m )
{ this -> init ( & _M_stringbuf ) ; }
#552
explicit
basic_stringstream ( const __string_type & __str ,
ios_base :: openmode __m = ios_base :: out | ios_base :: in )
: __iostream_type ( ) , _M_stringbuf ( __str , __m )
{ this -> init ( & _M_stringbuf ) ; }
#564
~ basic_stringstream ( )
{ }
#574
__stringbuf_type *
rdbuf ( ) const
{ return const_cast < __stringbuf_type * > ( & _M_stringbuf ) ; }





__string_type
str ( ) const
{ return _M_stringbuf . str ( ) ; }
#592
void
str ( const __string_type & __s )
{ _M_stringbuf . str ( __s ) ; }
} ;


}
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/bits/sstream.tcc"
#37
#pragma GCC system_header

namespace std
{


template < class _CharT , class _Traits , class _Alloc >
typename basic_stringbuf < _CharT , _Traits , _Alloc > :: int_type
basic_stringbuf < _CharT , _Traits , _Alloc > ::
pbackfail ( int_type __c )
{
int_type __ret = traits_type :: eof ( ) ;
if ( this -> eback ( ) < this -> gptr ( ) )
{


const bool __testeof = traits_type :: eq_int_type ( __c , __ret ) ;
if ( ! __testeof )
{
const bool __testeq = traits_type :: eq ( traits_type ::
to_char_type ( __c ) ,
this -> gptr ( ) [ - 1 ] ) ;
const bool __testout = this -> _M_mode & ios_base :: out ;
if ( __testeq || __testout )
{
this -> gbump ( - 1 ) ;
if ( ! __testeq )
* this -> gptr ( ) = traits_type :: to_char_type ( __c ) ;
__ret = __c ;
}
}
else
{
this -> gbump ( - 1 ) ;
__ret = traits_type :: not_eof ( __c ) ;
}
}
return __ret ;
}

template < class _CharT , class _Traits , class _Alloc >
typename basic_stringbuf < _CharT , _Traits , _Alloc > :: int_type
basic_stringbuf < _CharT , _Traits , _Alloc > ::
overflow ( int_type __c )
{
const bool __testout = this -> _M_mode & ios_base :: out ;
if ( ! __testout )
return traits_type :: eof ( ) ;

const bool __testeof = traits_type :: eq_int_type ( __c , traits_type :: eof ( ) ) ;
if ( __testeof )
return traits_type :: not_eof ( __c ) ;

const __size_type __capacity = _M_string . capacity ( ) ;
const __size_type __max_size = _M_string . max_size ( ) ;
const bool __testput = this -> pptr ( ) < this -> epptr ( ) ;
if ( ! __testput && __capacity == __max_size )
return traits_type :: eof ( ) ;



const char_type __conv = traits_type :: to_char_type ( __c ) ;
if ( ! __testput )
{
#110
const __size_type __opt_len = std :: max ( __size_type ( 2 * __capacity ) ,
__size_type ( 512 ) ) ;
const __size_type __len = std :: min ( __opt_len , __max_size ) ;
__string_type __tmp ;
__tmp . reserve ( __len ) ;
if ( this -> pbase ( ) )
__tmp . assign ( this -> pbase ( ) , this -> epptr ( ) - this -> pbase ( ) ) ;
__tmp . push_back ( __conv ) ;
_M_string . swap ( __tmp ) ;
_M_sync ( const_cast < char_type * > ( _M_string . data ( ) ) ,
this -> gptr ( ) - this -> eback ( ) , this -> pptr ( ) - this -> pbase ( ) ) ;
}
else
* this -> pptr ( ) = __conv ;
this -> pbump ( 1 ) ;
return __c ;
}

template < class _CharT , class _Traits , class _Alloc >
typename basic_stringbuf < _CharT , _Traits , _Alloc > :: int_type
basic_stringbuf < _CharT , _Traits , _Alloc > ::
underflow ( )
{
int_type __ret = traits_type :: eof ( ) ;
const bool __testin = this -> _M_mode & ios_base :: in ;
if ( __testin )
{

_M_update_egptr ( ) ;

if ( this -> gptr ( ) < this -> egptr ( ) )
__ret = traits_type :: to_int_type ( * this -> gptr ( ) ) ;
}
return __ret ;
}

template < class _CharT , class _Traits , class _Alloc >
typename basic_stringbuf < _CharT , _Traits , _Alloc > :: pos_type
basic_stringbuf < _CharT , _Traits , _Alloc > ::
seekoff ( off_type __off , ios_base :: seekdir __way , ios_base :: openmode __mode )
{
pos_type __ret = pos_type ( off_type ( - 1 ) ) ;
bool __testin = ( ios_base :: in & this -> _M_mode & __mode ) != 0 ;
bool __testout = ( ios_base :: out & this -> _M_mode & __mode ) != 0 ;
const bool __testboth = __testin && __testout && __way != ios_base :: cur ;
__testin &= ! ( __mode & ios_base :: out ) ;
__testout &= ! ( __mode & ios_base :: in ) ;



const char_type * __beg = __testin ? this -> eback ( ) : this -> pbase ( ) ;
if ( ( __beg || ! __off ) && ( __testin || __testout || __testboth ) )
{
_M_update_egptr ( ) ;

off_type __newoffi = __off ;
off_type __newoffo = __newoffi ;
if ( __way == ios_base :: cur )
{
__newoffi += this -> gptr ( ) - __beg ;
__newoffo += this -> pptr ( ) - __beg ;
}
else if ( __way == ios_base :: end )
__newoffo = __newoffi += this -> egptr ( ) - __beg ;

if ( ( __testin || __testboth )
&& __newoffi >= 0
&& this -> egptr ( ) - __beg >= __newoffi )
{
this -> setg ( this -> eback ( ) , this -> eback ( ) + __newoffi ,
this -> egptr ( ) ) ;
__ret = pos_type ( __newoffi ) ;
}
if ( ( __testout || __testboth )
&& __newoffo >= 0
&& this -> egptr ( ) - __beg >= __newoffo )
{
_M_pbump ( this -> pbase ( ) , this -> epptr ( ) , __newoffo ) ;
__ret = pos_type ( __newoffo ) ;
}
}
return __ret ;
}

template < class _CharT , class _Traits , class _Alloc >
typename basic_stringbuf < _CharT , _Traits , _Alloc > :: pos_type
basic_stringbuf < _CharT , _Traits , _Alloc > ::
seekpos ( pos_type __sp , ios_base :: openmode __mode )
{
pos_type __ret = pos_type ( off_type ( - 1 ) ) ;
const bool __testin = ( ios_base :: in & this -> _M_mode & __mode ) != 0 ;
const bool __testout = ( ios_base :: out & this -> _M_mode & __mode ) != 0 ;

const char_type * __beg = __testin ? this -> eback ( ) : this -> pbase ( ) ;
if ( ( __beg || ! off_type ( __sp ) ) && ( __testin || __testout ) )
{
_M_update_egptr ( ) ;

const off_type __pos ( __sp ) ;
const bool __testpos = ( 0 <= __pos
&& __pos <= this -> egptr ( ) - __beg ) ;
if ( __testpos )
{
if ( __testin )
this -> setg ( this -> eback ( ) , this -> eback ( ) + __pos ,
this -> egptr ( ) ) ;
if ( __testout )
_M_pbump ( this -> pbase ( ) , this -> epptr ( ) , __pos ) ;
__ret = __sp ;
}
}
return __ret ;
}

template < class _CharT , class _Traits , class _Alloc >
void
basic_stringbuf < _CharT , _Traits , _Alloc > ::
_M_sync ( char_type * __base , __size_type __i , __size_type __o )
{
const bool __testin = _M_mode & ios_base :: in ;
const bool __testout = _M_mode & ios_base :: out ;
char_type * __endg = __base + _M_string . size ( ) ;
char_type * __endp = __base + _M_string . capacity ( ) ;

if ( __base != _M_string . data ( ) )
{

__endg += __i ;
__i = 0 ;
__endp = __endg ;
}

if ( __testin )
this -> setg ( __base , __base + __i , __endg ) ;
if ( __testout )
{
_M_pbump ( __base , __endp , __o ) ;



if ( ! __testin )
this -> setg ( __endg , __endg , __endg ) ;
}
}

template < class _CharT , class _Traits , class _Alloc >
void
basic_stringbuf < _CharT , _Traits , _Alloc > ::
_M_pbump ( char_type * __pbeg , char_type * __pend , off_type __off )
{
this -> setp ( __pbeg , __pend ) ;
while ( __off > __gnu_cxx :: __numeric_traits < int > :: __max )
{
this -> pbump ( __gnu_cxx :: __numeric_traits < int > :: __max ) ;
__off -= __gnu_cxx :: __numeric_traits < int > :: __max ;
}
this -> pbump ( __off ) ;
}




extern template class basic_stringbuf < char > ;
extern template class basic_istringstream < char > ;
extern template class basic_ostringstream < char > ;
extern template class basic_stringstream < char > ;


extern template class basic_stringbuf < wchar_t > ;
extern template class basic_istringstream < wchar_t > ;
extern template class basic_ostringstream < wchar_t > ;
extern template class basic_stringstream < wchar_t > ;




}
#50 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/complex"
namespace std
{
#63
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 > & ) ;
#97
template < typename _Tp > complex < _Tp > pow ( const complex < _Tp > & , const _Tp & ) ;

template < typename _Tp > complex < _Tp > pow ( const complex < _Tp > & ,
const complex < _Tp > & ) ;

template < typename _Tp > complex < _Tp > pow ( const _Tp & , const complex < _Tp > & ) ;

template < typename _Tp > complex < _Tp > sin ( const complex < _Tp > & ) ;

template < typename _Tp > complex < _Tp > sinh ( const complex < _Tp > & ) ;

template < typename _Tp > complex < _Tp > sqrt ( const complex < _Tp > & ) ;

template < typename _Tp > complex < _Tp > tan ( const complex < _Tp > & ) ;

template < typename _Tp > complex < _Tp > tanh ( const complex < _Tp > & ) ;
#124
template < typename _Tp >
struct complex
{

typedef _Tp value_type ;



constexpr complex ( const _Tp & __r = _Tp ( ) , const _Tp & __i = _Tp ( ) )
: _M_real ( __r ) , _M_imag ( __i ) { }




template < typename _Up >
constexpr complex ( const complex < _Up > & __z )
: _M_real ( __z . real ( ) ) , _M_imag ( __z . imag ( ) ) { }




__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr _Tp
real ( ) { return _M_real ; }

__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr _Tp
imag ( ) { return _M_imag ; }
#172
void
real ( _Tp __val ) { _M_real = __val ; }

void
imag ( _Tp __val ) { _M_imag = __val ; }


complex < _Tp > & operator = ( const _Tp & ) ;



complex < _Tp > &
operator += ( const _Tp & __t )
{
_M_real += __t ;
return * this ;
}



complex < _Tp > &
operator -= ( const _Tp & __t )
{
_M_real -= __t ;
return * this ;
}


complex < _Tp > & operator *= ( const _Tp & ) ;

complex < _Tp > & operator /= ( const _Tp & ) ;





template < typename _Up >
complex < _Tp > & operator = ( const complex < _Up > & ) ;

template < typename _Up >
complex < _Tp > & operator += ( const complex < _Up > & ) ;

template < typename _Up >
complex < _Tp > & operator -= ( const complex < _Up > & ) ;

template < typename _Up >
complex < _Tp > & operator *= ( const complex < _Up > & ) ;

template < typename _Up >
complex < _Tp > & operator /= ( const complex < _Up > & ) ;

constexpr complex __rep ( ) const
{ return * this ; }

private :
_Tp _M_real ;
_Tp _M_imag ;
} ;

template < typename _Tp >
complex < _Tp > &
complex < _Tp > :: operator = ( const _Tp & __t )
{
_M_real = __t ;
_M_imag = _Tp ( ) ;
return * this ;
}


template < typename _Tp >
complex < _Tp > &
complex < _Tp > :: operator *= ( const _Tp & __t )
{
_M_real *= __t ;
_M_imag *= __t ;
return * this ;
}


template < typename _Tp >
complex < _Tp > &
complex < _Tp > :: operator /= ( const _Tp & __t )
{
_M_real /= __t ;
_M_imag /= __t ;
return * this ;
}

template < typename _Tp >
template < typename _Up >
complex < _Tp > &
complex < _Tp > :: operator = ( const complex < _Up > & __z )
{
_M_real = __z . real ( ) ;
_M_imag = __z . imag ( ) ;
return * this ;
}


template < typename _Tp >
template < typename _Up >
complex < _Tp > &
complex < _Tp > :: operator += ( const complex < _Up > & __z )
{
_M_real += __z . real ( ) ;
_M_imag += __z . imag ( ) ;
return * this ;
}


template < typename _Tp >
template < typename _Up >
complex < _Tp > &
complex < _Tp > :: operator -= ( const complex < _Up > & __z )
{
_M_real -= __z . real ( ) ;
_M_imag -= __z . imag ( ) ;
return * this ;
}



template < typename _Tp >
template < typename _Up >
complex < _Tp > &
complex < _Tp > :: operator *= ( const complex < _Up > & __z )
{
const _Tp __r = _M_real * __z . real ( ) - _M_imag * __z . imag ( ) ;
_M_imag = _M_real * __z . imag ( ) + _M_imag * __z . real ( ) ;
_M_real = __r ;
return * this ;
}



template < typename _Tp >
template < typename _Up >
complex < _Tp > &
complex < _Tp > :: operator /= ( const complex < _Up > & __z )
{
const _Tp __r = _M_real * __z . real ( ) + _M_imag * __z . imag ( ) ;
const _Tp __n = std :: norm ( __z ) ;
_M_imag = ( _M_imag * __z . real ( ) - _M_real * __z . imag ( ) ) / __n ;
_M_real = __r / __n ;
return * this ;
}




template < typename _Tp >
inline complex < _Tp >
operator + ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r = __x ;
__r += __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator + ( const complex < _Tp > & __x , const _Tp & __y )
{
complex < _Tp > __r = __x ;
__r += __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator + ( const _Tp & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r = __y ;
__r += __x ;
return __r ;
}




template < typename _Tp >
inline complex < _Tp >
operator - ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r = __x ;
__r -= __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator - ( const complex < _Tp > & __x , const _Tp & __y )
{
complex < _Tp > __r = __x ;
__r -= __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator - ( const _Tp & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r ( __x , - __y . imag ( ) ) ;
__r -= __y . real ( ) ;
return __r ;
}




template < typename _Tp >
inline complex < _Tp >
operator * ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r = __x ;
__r *= __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator * ( const complex < _Tp > & __x , const _Tp & __y )
{
complex < _Tp > __r = __x ;
__r *= __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator * ( const _Tp & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r = __y ;
__r *= __x ;
return __r ;
}




template < typename _Tp >
inline complex < _Tp >
operator / ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r = __x ;
__r /= __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator / ( const complex < _Tp > & __x , const _Tp & __y )
{
complex < _Tp > __r = __x ;
__r /= __y ;
return __r ;
}

template < typename _Tp >
inline complex < _Tp >
operator / ( const _Tp & __x , const complex < _Tp > & __y )
{
complex < _Tp > __r = __x ;
__r /= __y ;
return __r ;
}



template < typename _Tp >
inline complex < _Tp >
operator + ( const complex < _Tp > & __x )
{ return __x ; }


template < typename _Tp >
inline complex < _Tp >
operator - ( const complex < _Tp > & __x )
{ return complex < _Tp > ( - __x . real ( ) , - __x . imag ( ) ) ; }



template < typename _Tp >
inline constexpr bool
operator == ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{ return __x . real ( ) == __y . real ( ) && __x . imag ( ) == __y . imag ( ) ; }

template < typename _Tp >
inline constexpr bool
operator == ( const complex < _Tp > & __x , const _Tp & __y )
{ return __x . real ( ) == __y && __x . imag ( ) == _Tp ( ) ; }

template < typename _Tp >
inline constexpr bool
operator == ( const _Tp & __x , const complex < _Tp > & __y )
{ return __x == __y . real ( ) && _Tp ( ) == __y . imag ( ) ; }




template < typename _Tp >
inline constexpr bool
operator != ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{ return __x . real ( ) != __y . real ( ) || __x . imag ( ) != __y . imag ( ) ; }

template < typename _Tp >
inline constexpr bool
operator != ( const complex < _Tp > & __x , const _Tp & __y )
{ return __x . real ( ) != __y || __x . imag ( ) != _Tp ( ) ; }

template < typename _Tp >
inline constexpr bool
operator != ( const _Tp & __x , const complex < _Tp > & __y )
{ return __x != __y . real ( ) || _Tp ( ) != __y . imag ( ) ; }



template < typename _Tp , typename _CharT , class _Traits >
basic_istream < _CharT , _Traits > &
operator >> ( basic_istream < _CharT , _Traits > & __is , complex < _Tp > & __x )
{
_Tp __re_x , __im_x ;
_CharT __ch ;
__is >> __ch ;
if ( __ch == '(' )
{
__is >> __re_x >> __ch ;
if ( __ch == ',' )
{
__is >> __im_x >> __ch ;
if ( __ch == ')' )
__x = complex < _Tp > ( __re_x , __im_x ) ;
else
__is . setstate ( ios_base :: failbit ) ;
}
else if ( __ch == ')' )
__x = __re_x ;
else
__is . setstate ( ios_base :: failbit ) ;
}
else
{
__is . putback ( __ch ) ;
__is >> __re_x ;
__x = __re_x ;
}
return __is ;
}


template < typename _Tp , typename _CharT , class _Traits >
basic_ostream < _CharT , _Traits > &
operator << ( basic_ostream < _CharT , _Traits > & __os , const complex < _Tp > & __x )
{
basic_ostringstream < _CharT , _Traits > __s ;
__s . flags ( __os . flags ( ) ) ;
__s . imbue ( __os . getloc ( ) ) ;
__s . precision ( __os . precision ( ) ) ;
__s << '(' << __x . real ( ) << ',' << __x . imag ( ) << ')' ;
return __os << __s . str ( ) ;
}



template < typename _Tp >
constexpr _Tp
real ( const complex < _Tp > & __z )
{ return __z . real ( ) ; }

template < typename _Tp >
constexpr _Tp
imag ( const complex < _Tp > & __z )
{ return __z . imag ( ) ; }
#568
template < typename _Tp >
inline _Tp
__complex_abs ( const complex < _Tp > & __z )
{
_Tp __x = __z . real ( ) ;
_Tp __y = __z . imag ( ) ;
const _Tp __s = std :: max ( abs ( __x ) , abs ( __y ) ) ;
if ( __s == _Tp ( ) )
return __s ;
__x /= __s ;
__y /= __s ;
return __s * sqrt ( __x * __x + __y * __y ) ;
}
#597
template < typename _Tp >
inline _Tp
abs ( const complex < _Tp > & __z ) { return __complex_abs ( __z ) ; }




template < typename _Tp >
inline _Tp
__complex_arg ( const complex < _Tp > & __z )
{ return atan2 ( __z . imag ( ) , __z . real ( ) ) ; }
#624
template < typename _Tp >
inline _Tp
arg ( const complex < _Tp > & __z ) { return __complex_arg ( __z ) ; }
#634
template < bool >
struct _Norm_helper
{
template < typename _Tp >
static inline _Tp _S_do_it ( const complex < _Tp > & __z )
{
const _Tp __x = __z . real ( ) ;
const _Tp __y = __z . imag ( ) ;
return __x * __x + __y * __y ;
}
} ;

template < >
struct _Norm_helper < true >
{
template < typename _Tp >
static inline _Tp _S_do_it ( const complex < _Tp > & __z )
{
_Tp __res = std :: abs ( __z ) ;
return __res * __res ;
}
} ;

template < typename _Tp >
inline _Tp
norm ( const complex < _Tp > & __z )
{
return _Norm_helper < __is_floating < _Tp > :: __value
&& ! 0 > :: _S_do_it ( __z ) ;
}

template < typename _Tp >
inline complex < _Tp >
polar ( const _Tp & __rho , const _Tp & __theta )
{ return complex < _Tp > ( __rho * cos ( __theta ) , __rho * sin ( __theta ) ) ; }

template < typename _Tp >
inline complex < _Tp >
conj ( const complex < _Tp > & __z )
{ return complex < _Tp > ( __z . real ( ) , - __z . imag ( ) ) ; }




template < typename _Tp >
inline complex < _Tp >
__complex_cos ( const complex < _Tp > & __z )
{
const _Tp __x = __z . real ( ) ;
const _Tp __y = __z . imag ( ) ;
return complex < _Tp > ( cos ( __x ) * cosh ( __y ) , - sin ( __x ) * sinh ( __y ) ) ;
}
#702
template < typename _Tp >
inline complex < _Tp >
cos ( const complex < _Tp > & __z ) { return __complex_cos ( __z ) ; }



template < typename _Tp >
inline complex < _Tp >
__complex_cosh ( const complex < _Tp > & __z )
{
const _Tp __x = __z . real ( ) ;
const _Tp __y = __z . imag ( ) ;
return complex < _Tp > ( cosh ( __x ) * cos ( __y ) , sinh ( __x ) * sin ( __y ) ) ;
}
#732
template < typename _Tp >
inline complex < _Tp >
cosh ( const complex < _Tp > & __z ) { return __complex_cosh ( __z ) ; }



template < typename _Tp >
inline complex < _Tp >
__complex_exp ( const complex < _Tp > & __z )
{ return std :: polar ( exp ( __z . real ( ) ) , __z . imag ( ) ) ; }
#758
template < typename _Tp >
inline complex < _Tp >
exp ( const complex < _Tp > & __z ) { return __complex_exp ( __z ) ; }




template < typename _Tp >
inline complex < _Tp >
__complex_log ( const complex < _Tp > & __z )
{ return complex < _Tp > ( log ( std :: abs ( __z ) ) , std :: arg ( __z ) ) ; }
#785
template < typename _Tp >
inline complex < _Tp >
log ( const complex < _Tp > & __z ) { return __complex_log ( __z ) ; }


template < typename _Tp >
inline complex < _Tp >
log10 ( const complex < _Tp > & __z )
{ return std :: log ( __z ) / log ( _Tp ( 10.0 ) ) ; }


template < typename _Tp >
inline complex < _Tp >
__complex_sin ( const complex < _Tp > & __z )
{
const _Tp __x = __z . real ( ) ;
const _Tp __y = __z . imag ( ) ;
return complex < _Tp > ( sin ( __x ) * cosh ( __y ) , cos ( __x ) * sinh ( __y ) ) ;
}
#820
template < typename _Tp >
inline complex < _Tp >
sin ( const complex < _Tp > & __z ) { return __complex_sin ( __z ) ; }



template < typename _Tp >
inline complex < _Tp >
__complex_sinh ( const complex < _Tp > & __z )
{
const _Tp __x = __z . real ( ) ;
const _Tp __y = __z . imag ( ) ;
return complex < _Tp > ( sinh ( __x ) * cos ( __y ) , cosh ( __x ) * sin ( __y ) ) ;
}
#850
template < typename _Tp >
inline complex < _Tp >
sinh ( const complex < _Tp > & __z ) { return __complex_sinh ( __z ) ; }




template < typename _Tp >
complex < _Tp >
__complex_sqrt ( const complex < _Tp > & __z )
{
_Tp __x = __z . real ( ) ;
_Tp __y = __z . imag ( ) ;

if ( __x == _Tp ( ) )
{
_Tp __t = sqrt ( abs ( __y ) / 2 ) ;
return complex < _Tp > ( __t , __y < _Tp ( ) ? - __t : __t ) ;
}
else
{
_Tp __t = sqrt ( 2 * ( std :: abs ( __z ) + abs ( __x ) ) ) ;
_Tp __u = __t / 2 ;
return __x > _Tp ( )
? complex < _Tp > ( __u , __y / __t )
: complex < _Tp > ( abs ( __y ) / __t , __y < _Tp ( ) ? - __u : __u ) ;
}
}
#894
template < typename _Tp >
inline complex < _Tp >
sqrt ( const complex < _Tp > & __z ) { return __complex_sqrt ( __z ) ; }




template < typename _Tp >
inline complex < _Tp >
__complex_tan ( const complex < _Tp > & __z )
{ return std :: sin ( __z ) / std :: cos ( __z ) ; }
#921
template < typename _Tp >
inline complex < _Tp >
tan ( const complex < _Tp > & __z ) { return __complex_tan ( __z ) ; }





template < typename _Tp >
inline complex < _Tp >
__complex_tanh ( const complex < _Tp > & __z )
{ return std :: sinh ( __z ) / std :: cosh ( __z ) ; }
#949
template < typename _Tp >
inline complex < _Tp >
tanh ( const complex < _Tp > & __z ) { return __complex_tanh ( __z ) ; }
#987
template < typename _Tp >
complex < _Tp >
pow ( const complex < _Tp > & __x , const _Tp & __y )
{

if ( __x == _Tp ( ) )
return _Tp ( ) ;

if ( __x . imag ( ) == _Tp ( ) && __x . real ( ) > _Tp ( ) )
return pow ( __x . real ( ) , __y ) ;

complex < _Tp > __t = std :: log ( __x ) ;
return std :: polar ( exp ( __y * __t . real ( ) ) , __y * __t . imag ( ) ) ;
}

template < typename _Tp >
inline complex < _Tp >
__complex_pow ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{ return __x == _Tp ( ) ? _Tp ( ) : std :: exp ( __y * std :: log ( __x ) ) ; }
#1026
template < typename _Tp >
inline complex < _Tp >
pow ( const complex < _Tp > & __x , const complex < _Tp > & __y )
{ return __complex_pow ( __x , __y ) ; }


template < typename _Tp >
inline complex < _Tp >
pow ( const _Tp & __x , const complex < _Tp > & __y )
{
return __x > _Tp ( ) ? std :: polar ( pow ( __x , __y . real ( ) ) ,
__y . imag ( ) * log ( __x ) )
: std :: pow ( complex < _Tp > ( __x ) , __y ) ;
}



template < >
struct complex < float >
{
typedef float value_type ;
typedef __complex__ float _ComplexT ;

constexpr complex ( _ComplexT __z ) : _M_value ( __z ) { }

constexpr complex ( float __r = 0.0f , float __i = 0.0f )

: _M_value { __r , __i } { }
#1061
explicit constexpr complex ( const complex < double > & ) ;
explicit constexpr complex ( const complex < long double > & ) ;




__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr float
real ( ) { return __real__ _M_value ; }

__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr float
imag ( ) { return __imag__ _M_value ; }
#1090
void
real ( float __val ) { __real__ _M_value = __val ; }

void
imag ( float __val ) { __imag__ _M_value = __val ; }

complex &
operator = ( float __f )
{
_M_value = __f ;
return * this ;
}

complex &
operator += ( float __f )
{
_M_value += __f ;
return * this ;
}

complex &
operator -= ( float __f )
{
_M_value -= __f ;
return * this ;
}

complex &
operator *= ( float __f )
{
_M_value *= __f ;
return * this ;
}

complex &
operator /= ( float __f )
{
_M_value /= __f ;
return * this ;
}





template < typename _Tp >
complex &
operator = ( const complex < _Tp > & __z )
{
__real__ _M_value = __z . real ( ) ;
__imag__ _M_value = __z . imag ( ) ;
return * this ;
}

template < typename _Tp >
complex &
operator += ( const complex < _Tp > & __z )
{
__real__ _M_value += __z . real ( ) ;
__imag__ _M_value += __z . imag ( ) ;
return * this ;
}

template < class _Tp >
complex &
operator -= ( const complex < _Tp > & __z )
{
__real__ _M_value -= __z . real ( ) ;
__imag__ _M_value -= __z . imag ( ) ;
return * this ;
}

template < class _Tp >
complex &
operator *= ( const complex < _Tp > & __z )
{
_ComplexT __t ;
__real__ __t = __z . real ( ) ;
__imag__ __t = __z . imag ( ) ;
_M_value *= __t ;
return * this ;
}

template < class _Tp >
complex &
operator /= ( const complex < _Tp > & __z )
{
_ComplexT __t ;
__real__ __t = __z . real ( ) ;
__imag__ __t = __z . imag ( ) ;
_M_value /= __t ;
return * this ;
}

constexpr _ComplexT __rep ( ) const { return _M_value ; }

private :
_ComplexT _M_value ;
} ;



template < >
struct complex < double >
{
typedef double value_type ;
typedef __complex__ double _ComplexT ;

constexpr complex ( _ComplexT __z ) : _M_value ( __z ) { }

constexpr complex ( double __r = 0.0 , double __i = 0.0 )

: _M_value { __r , __i } { }
#1210
constexpr complex ( const complex < float > & __z )
: _M_value ( __z . __rep ( ) ) { }

explicit constexpr complex ( const complex < long double > & ) ;




__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr double
real ( ) { return __real__ _M_value ; }

__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr double
imag ( ) { return __imag__ _M_value ; }
#1241
void
real ( double __val ) { __real__ _M_value = __val ; }

void
imag ( double __val ) { __imag__ _M_value = __val ; }

complex &
operator = ( double __d )
{
_M_value = __d ;
return * this ;
}

complex &
operator += ( double __d )
{
_M_value += __d ;
return * this ;
}

complex &
operator -= ( double __d )
{
_M_value -= __d ;
return * this ;
}

complex &
operator *= ( double __d )
{
_M_value *= __d ;
return * this ;
}

complex &
operator /= ( double __d )
{
_M_value /= __d ;
return * this ;
}




template < typename _Tp >
complex &
operator = ( const complex < _Tp > & __z )
{
__real__ _M_value = __z . real ( ) ;
__imag__ _M_value = __z . imag ( ) ;
return * this ;
}

template < typename _Tp >
complex &
operator += ( const complex < _Tp > & __z )
{
__real__ _M_value += __z . real ( ) ;
__imag__ _M_value += __z . imag ( ) ;
return * this ;
}

template < typename _Tp >
complex &
operator -= ( const complex < _Tp > & __z )
{
__real__ _M_value -= __z . real ( ) ;
__imag__ _M_value -= __z . imag ( ) ;
return * this ;
}

template < typename _Tp >
complex &
operator *= ( const complex < _Tp > & __z )
{
_ComplexT __t ;
__real__ __t = __z . real ( ) ;
__imag__ __t = __z . imag ( ) ;
_M_value *= __t ;
return * this ;
}

template < typename _Tp >
complex &
operator /= ( const complex < _Tp > & __z )
{
_ComplexT __t ;
__real__ __t = __z . real ( ) ;
__imag__ __t = __z . imag ( ) ;
_M_value /= __t ;
return * this ;
}

constexpr _ComplexT __rep ( ) const { return _M_value ; }

private :
_ComplexT _M_value ;
} ;



template < >
struct complex < long double >
{
typedef long double value_type ;
typedef __complex__ long double _ComplexT ;

constexpr complex ( _ComplexT __z ) : _M_value ( __z ) { }

constexpr complex ( long double __r = 0.0L ,
long double __i = 0.0L )

: _M_value { __r , __i } { }
#1361
constexpr complex ( const complex < float > & __z )
: _M_value ( __z . __rep ( ) ) { }

constexpr complex ( const complex < double > & __z )
: _M_value ( __z . __rep ( ) ) { }




__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr long double
real ( ) { return __real__ _M_value ; }

__attribute__ ( ( __abi_tag__ ( "cxx11" ) ) )
constexpr long double
imag ( ) { return __imag__ _M_value ; }
#1393
void
real ( long double __val ) { __real__ _M_value = __val ; }

void
imag ( long double __val ) { __imag__ _M_value = __val ; }

complex &
operator = ( long double __r )
{
_M_value = __r ;
return * this ;
}

complex &
operator += ( long double __r )
{
_M_value += __r ;
return * this ;
}

complex &
operator -= ( long double __r )
{
_M_value -= __r ;
return * this ;
}

complex &
operator *= ( long double __r )
{
_M_value *= __r ;
return * this ;
}

complex &
operator /= ( long double __r )
{
_M_value /= __r ;
return * this ;
}




template < typename _Tp >
complex &
operator = ( const complex < _Tp > & __z )
{
__real__ _M_value = __z . real ( ) ;
__imag__ _M_value = __z . imag ( ) ;
return * this ;
}

template < typename _Tp >
complex &
operator += ( const complex < _Tp > & __z )
{
__real__ _M_value += __z . real ( ) ;
__imag__ _M_value += __z . imag ( ) ;
return * this ;
}

template < typename _Tp >
complex &
operator -= ( const complex < _Tp > & __z )
{
__real__ _M_value -= __z . real ( ) ;
__imag__ _M_value -= __z . imag ( ) ;
return * this ;
}

template < typename _Tp >
complex &
operator *= ( const complex < _Tp > & __z )
{
_ComplexT __t ;
__real__ __t = __z . real ( ) ;
__imag__ __t = __z . imag ( ) ;
_M_value *= __t ;
return * this ;
}

template < typename _Tp >
complex &
operator /= ( const complex < _Tp > & __z )
{
_ComplexT __t ;
__real__ __t = __z . real ( ) ;
__imag__ __t = __z . imag ( ) ;
_M_value /= __t ;
return * this ;
}

constexpr _ComplexT __rep ( ) const { return _M_value ; }

private :
_ComplexT _M_value ;
} ;



inline constexpr
complex < float > :: complex ( const complex < double > & __z )
: _M_value ( __z . __rep ( ) ) { }

inline constexpr
complex < float > :: complex ( const complex < long double > & __z )
: _M_value ( __z . __rep ( ) ) { }

inline constexpr
complex < double > :: complex ( const complex < long double > & __z )
: _M_value ( __z . __rep ( ) ) { }





extern template istream & operator >> ( istream & , complex < float > & ) ;
extern template ostream & operator << ( ostream & , const complex < float > & ) ;
extern template istream & operator >> ( istream & , complex < double > & ) ;
extern template ostream & operator << ( ostream & , const complex < double > & ) ;
extern template istream & operator >> ( istream & , complex < long double > & ) ;
extern template ostream & operator << ( ostream & , const complex < long double > & ) ;


extern template wistream & operator >> ( wistream & , complex < float > & ) ;
extern template wostream & operator << ( wostream & , const complex < float > & ) ;
extern template wistream & operator >> ( wistream & , complex < double > & ) ;
extern template wostream & operator << ( wostream & , const complex < double > & ) ;
extern template wistream & operator >> ( wistream & , complex < long double > & ) ;
extern template wostream & operator << ( wostream & , const complex < long double > & ) ;
#1530
}

namespace __gnu_cxx
{



template < typename _Tp , typename _Up >
struct __promote_2 < std :: complex < _Tp > , _Up >
{
public :
typedef std :: complex < typename __promote_2 < _Tp , _Up > :: __type > __type ;
} ;

template < typename _Tp , typename _Up >
struct __promote_2 < _Tp , std :: complex < _Up > >
{
public :
typedef std :: complex < typename __promote_2 < _Tp , _Up > :: __type > __type ;
} ;

template < typename _Tp , typename _Up >
struct __promote_2 < std :: complex < _Tp > , std :: complex < _Up > >
{
public :
typedef std :: complex < typename __promote_2 < _Tp , _Up > :: __type > __type ;
} ;


}



namespace std
{



template < typename _Tp > std :: complex < _Tp > acos ( const std :: complex < _Tp > & ) ;
template < typename _Tp > std :: complex < _Tp > asin ( const std :: complex < _Tp > & ) ;
template < typename _Tp > std :: complex < _Tp > atan ( const std :: complex < _Tp > & ) ;

template < typename _Tp > std :: complex < _Tp > acosh ( const std :: complex < _Tp > & ) ;
template < typename _Tp > std :: complex < _Tp > asinh ( const std :: complex < _Tp > & ) ;
template < typename _Tp > std :: complex < _Tp > atanh ( const std :: complex < _Tp > & ) ;

template < typename _Tp > _Tp fabs ( const std :: complex < _Tp > & ) ;

template < typename _Tp >
inline std :: complex < _Tp >
__complex_acos ( const std :: complex < _Tp > & __z )
{
const std :: complex < _Tp > __t = std :: asin ( __z ) ;
const _Tp __pi_2 = 1.5707963267948966192313216916397514L ;
return std :: complex < _Tp > ( __pi_2 - __t . real ( ) , - __t . imag ( ) ) ;
}
#1608
template < typename _Tp >
inline std :: complex < _Tp >
acos ( const std :: complex < _Tp > & __z )
{ return __complex_acos ( __z ) ; }


template < typename _Tp >
inline std :: complex < _Tp >
__complex_asin ( const std :: complex < _Tp > & __z )
{
std :: complex < _Tp > __t ( - __z . imag ( ) , __z . real ( ) ) ;
__t = std :: asinh ( __t ) ;
return std :: complex < _Tp > ( __t . imag ( ) , - __t . real ( ) ) ;
}
#1644
template < typename _Tp >
inline std :: complex < _Tp >
asin ( const std :: complex < _Tp > & __z )
{ return __complex_asin ( __z ) ; }


template < typename _Tp >
std :: complex < _Tp >
__complex_atan ( const std :: complex < _Tp > & __z )
{
const _Tp __r2 = __z . real ( ) * __z . real ( ) ;
const _Tp __x = _Tp ( 1.0 ) - __r2 - __z . imag ( ) * __z . imag ( ) ;

_Tp __num = __z . imag ( ) + _Tp ( 1.0 ) ;
_Tp __den = __z . imag ( ) - _Tp ( 1.0 ) ;

__num = __r2 + __num * __num ;
__den = __r2 + __den * __den ;

return std :: complex < _Tp > ( _Tp ( 0.5 ) * atan2 ( _Tp ( 2.0 ) * __z . real ( ) , __x ) ,
_Tp ( 0.25 ) * log ( __num / __den ) ) ;
}
#1688
template < typename _Tp >
inline std :: complex < _Tp >
atan ( const std :: complex < _Tp > & __z )
{ return __complex_atan ( __z ) ; }


template < typename _Tp >
std :: complex < _Tp >
__complex_acosh ( const std :: complex < _Tp > & __z )
{

return _Tp ( 2.0 ) * std :: log ( std :: sqrt ( _Tp ( 0.5 ) * ( __z + _Tp ( 1.0 ) ) )
+ std :: sqrt ( _Tp ( 0.5 ) * ( __z - _Tp ( 1.0 ) ) ) ) ;
}
#1724
template < typename _Tp >
inline std :: complex < _Tp >
acosh ( const std :: complex < _Tp > & __z )
{ return __complex_acosh ( __z ) ; }


template < typename _Tp >
std :: complex < _Tp >
__complex_asinh ( const std :: complex < _Tp > & __z )
{
std :: complex < _Tp > __t ( ( __z . real ( ) - __z . imag ( ) )
* ( __z . real ( ) + __z . imag ( ) ) + _Tp ( 1.0 ) ,
_Tp ( 2.0 ) * __z . real ( ) * __z . imag ( ) ) ;
__t = std :: sqrt ( __t ) ;

return std :: log ( __t + __z ) ;
}
#1763
template < typename _Tp >
inline std :: complex < _Tp >
asinh ( const std :: complex < _Tp > & __z )
{ return __complex_asinh ( __z ) ; }


template < typename _Tp >
std :: complex < _Tp >
__complex_atanh ( const std :: complex < _Tp > & __z )
{
const _Tp __i2 = __z . imag ( ) * __z . imag ( ) ;
const _Tp __x = _Tp ( 1.0 ) - __i2 - __z . real ( ) * __z . real ( ) ;

_Tp __num = _Tp ( 1.0 ) + __z . real ( ) ;
_Tp __den = _Tp ( 1.0 ) - __z . real ( ) ;

__num = __i2 + __num * __num ;
__den = __i2 + __den * __den ;

return std :: complex < _Tp > ( _Tp ( 0.25 ) * ( log ( __num ) - log ( __den ) ) ,
_Tp ( 0.5 ) * atan2 ( _Tp ( 2.0 ) * __z . imag ( ) , __x ) ) ;
}
#1807
template < typename _Tp >
inline std :: complex < _Tp >
atanh ( const std :: complex < _Tp > & __z )
{ return __complex_atanh ( __z ) ; }


template < typename _Tp >
inline _Tp



fabs ( const std :: complex < _Tp > & __z )
{ return std :: abs ( __z ) ; }


template < typename _Tp >
inline typename __gnu_cxx :: __promote < _Tp > :: __type
arg ( _Tp __x )
{
typedef typename __gnu_cxx :: __promote < _Tp > :: __type __type ;

return std :: signbit ( __x ) ? __type ( 3.1415926535897932384626433832795029L )
: __type ( ) ;



}

template < typename _Tp >
inline typename __gnu_cxx :: __promote < _Tp > :: __type
imag ( _Tp )
{ return _Tp ( ) ; }

template < typename _Tp >
inline typename __gnu_cxx :: __promote < _Tp > :: __type
norm ( _Tp __x )
{
typedef typename __gnu_cxx :: __promote < _Tp > :: __type __type ;
return __type ( __x ) * __type ( __x ) ;
}

template < typename _Tp >
inline typename __gnu_cxx :: __promote < _Tp > :: __type
real ( _Tp __x )
{ return __x ; }

template < typename _Tp , typename _Up >
inline std :: complex < typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type >
pow ( const std :: complex < _Tp > & __x , const _Up & __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return std :: pow ( std :: complex < __type > ( __x ) , __type ( __y ) ) ;
}

template < typename _Tp , typename _Up >
inline std :: complex < typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type >
pow ( const _Tp & __x , const std :: complex < _Up > & __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return std :: pow ( __type ( __x ) , std :: complex < __type > ( __y ) ) ;
}

template < typename _Tp , typename _Up >
inline std :: complex < typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type >
pow ( const std :: complex < _Tp > & __x , const std :: complex < _Up > & __y )
{
typedef typename __gnu_cxx :: __promote_2 < _Tp , _Up > :: __type __type ;
return std :: pow ( std :: complex < __type > ( __x ) ,
std :: complex < __type > ( __y ) ) ;
}



template < typename _Tp > std :: complex < _Tp > proj ( const std :: complex < _Tp > & ) ;

template < typename _Tp >
std :: complex < _Tp >
__complex_proj ( const std :: complex < _Tp > & __z )
{
const _Tp __den = ( __z . real ( ) * __z . real ( )
+ __z . imag ( ) * __z . imag ( ) + _Tp ( 1.0 ) ) ;

return std :: complex < _Tp > ( ( _Tp ( 2.0 ) * __z . real ( ) ) / __den ,
( _Tp ( 2.0 ) * __z . imag ( ) ) / __den ) ;
}
#1911
template < typename _Tp >
inline std :: complex < _Tp >
proj ( const std :: complex < _Tp > & __z )
{ return __complex_proj ( __z ) ; }



template < typename _Tp >
inline typename __gnu_cxx :: __promote < _Tp > :: __type
proj ( _Tp __x )
{ return __x ; }

template < typename _Tp >
inline typename __gnu_cxx :: __promote < _Tp > :: __type
conj ( _Tp __x )
{ return __x ; }


}
#1 "./boost/preprocessor/repetition/repeat_from_to.hpp"
#1 "./boost/preprocessor/detail/auto_rec.hpp"
#47 "./boost/functional/hash/extensions.hpp"
namespace boost
{
template < class A , class B >
std :: size_t hash_value ( std :: pair < A , B > const & ) ;
template < class T , class A >
std :: size_t hash_value ( std :: vector < T , A > const & ) ;
template < class T , class A >
std :: size_t hash_value ( std :: list < T , A > const & v ) ;
template < class T , class A >
std :: size_t hash_value ( std :: deque < T , A > const & v ) ;
template < class K , class C , class A >
std :: size_t hash_value ( std :: set < K , C , A > const & v ) ;
template < class K , class C , class A >
std :: size_t hash_value ( std :: multiset < K , C , A > const & v ) ;
template < class K , class T , class C , class A >
std :: size_t hash_value ( std :: map < K , T , C , A > const & v ) ;
template < class K , class T , class C , class A >
std :: size_t hash_value ( std :: multimap < K , T , C , A > const & v ) ;

template < class T >
std :: size_t hash_value ( std :: complex < T > const & ) ;

template < class A , class B >
std :: size_t hash_value ( std :: pair < A , B > const & v )
{
std :: size_t seed = 0 ;
boost :: hash_combine ( seed , v . first ) ;
boost :: hash_combine ( seed , v . second ) ;
return seed ;
}

template < class T , class A >
std :: size_t hash_value ( std :: vector < T , A > const & v )
{
return boost :: hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < class T , class A >
std :: size_t hash_value ( std :: list < T , A > const & v )
{
return boost :: hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < class T , class A >
std :: size_t hash_value ( std :: deque < T , A > const & v )
{
return boost :: hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < class K , class C , class A >
std :: size_t hash_value ( std :: set < K , C , A > const & v )
{
return boost :: hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < class K , class C , class A >
std :: size_t hash_value ( std :: multiset < K , C , A > const & v )
{
return boost :: hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < class K , class T , class C , class A >
std :: size_t hash_value ( std :: map < K , T , C , A > const & v )
{
return boost :: hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < class K , class T , class C , class A >
std :: size_t hash_value ( std :: multimap < K , T , C , A > const & v )
{
return boost :: hash_range ( v . begin ( ) , v . end ( ) ) ;
}

template < class T >
std :: size_t hash_value ( std :: complex < T > const & v )
{
boost :: hash < T > hasher ;
std :: size_t seed = hasher ( v . imag ( ) ) ;
seed ^= hasher ( v . real ( ) ) + ( seed << 6 ) + ( seed >> 2 ) ;
return seed ;
}
#263
template < class T > struct hash
: std :: unary_function < T , std :: size_t >
{

std :: size_t operator ( ) ( T const & val ) const
{
return hash_value ( val ) ;
}
#277
} ;
#377
}
#36 "./boost/regex/v4/basic_regex.hpp"
namespace boost {
#45
namespace re_detail {




template < class charT , class traits >
class basic_regex_parser ;

template < class I >
void bubble_down_one ( I first , I last )
{
if ( first != last )
{
I next = last - 1 ;
while ( ( next != first ) && ( * next < * ( next - 1 ) ) )
{
( next - 1 ) -> swap ( * next ) ;
-- next ;
}
}
}

template < class Iterator >
inline int hash_value_from_capture_name ( Iterator i , Iterator j )
{
std :: size_t r = boost :: hash_range ( i , j ) ;
r %= ( ( std :: numeric_limits < int > :: max ) ( ) - 10001 ) ;
r += 10000 ;
return static_cast < int > ( r ) ;
}

class named_subexpressions
{
public :
struct name
{
template < class charT >
name ( const charT * i , const charT * j , int idx )
: index ( idx )
{
hash = hash_value_from_capture_name ( i , j ) ;
}
name ( int h , int idx )
: index ( idx ) , hash ( h )
{
}
int index ;
int hash ;
bool operator < ( const name & other ) const
{
return hash < other . hash ;
}
bool operator == ( const name & other ) const
{
return hash == other . hash ;
}
void swap ( name & other )
{
std :: swap ( index , other . index ) ;
std :: swap ( hash , other . hash ) ;
}
} ;

typedef std :: vector < name > :: const_iterator const_iterator ;
typedef std :: pair < const_iterator , const_iterator > range_type ;

named_subexpressions ( ) { }

template < class charT >
void set_name ( const charT * i , const charT * j , int index )
{
m_sub_names . push_back ( name ( i , j , index ) ) ;
bubble_down_one ( m_sub_names . begin ( ) , m_sub_names . end ( ) ) ;
}
template < class charT >
int get_id ( const charT * i , const charT * j ) const
{
name t ( i , j , 0 ) ;
typename std :: vector < name > :: const_iterator pos = std :: lower_bound ( m_sub_names . begin ( ) , m_sub_names . end
#123
( ) , t ) ;
if ( ( pos != m_sub_names . end ( ) ) && ( * pos == t ) )
{
return pos -> index ;
}
return - 1 ;
}
template < class charT >
range_type equal_range ( const charT * i , const charT * j ) const
{
name t ( i , j , 0 ) ;
return std :: equal_range ( m_sub_names . begin ( ) , m_sub_names . end ( ) , t ) ;
}
int get_id ( int h ) const
{
name t ( h , 0 ) ;
std :: vector < name > :: const_iterator pos = std :: lower_bound ( m_sub_names . begin ( ) , m_sub_names . end ( ) , t )
#139
;
if ( ( pos != m_sub_names . end ( ) ) && ( * pos == t ) )
{
return pos -> index ;
}
return - 1 ;
}
range_type equal_range ( int h ) const
{
name t ( h , 0 ) ;
return std :: equal_range ( m_sub_names . begin ( ) , m_sub_names . end ( ) , t ) ;
}
private :
std :: vector < name > m_sub_names ;
} ;





template < class charT , class traits >
struct regex_data : public named_subexpressions
{
typedef regex_constants :: syntax_option_type flag_type ;
typedef std :: size_t size_type ;

regex_data ( const :: boost :: shared_ptr <
:: boost :: regex_traits_wrapper < traits > > & t )
: m_ptraits ( t ) , m_expression ( 0 ) , m_expression_len ( 0 ) { }
regex_data ( )
: m_ptraits ( new :: boost :: regex_traits_wrapper < traits > ( ) ) , m_expression ( 0 ) , m_expression_len ( 0 ) { }

:: boost :: shared_ptr <
:: boost :: regex_traits_wrapper < traits >
> m_ptraits ;
flag_type m_flags ;
int m_status ;
const charT * m_expression ;
std :: ptrdiff_t m_expression_len ;
size_type m_mark_count ;
re_detail :: re_syntax_base * m_first_state ;
unsigned m_restart_type ;
unsigned char m_startmap [ 1 << 8 ] ;
unsigned int m_can_be_null ;
re_detail :: raw_storage m_data ;
typename traits :: char_class_type m_word_mask ;
std :: vector <
std :: pair <
std :: size_t , std :: size_t > > m_subs ;
bool m_has_recursions ;
} ;




template < class charT , class traits >
class basic_regex_implementation
: public regex_data < charT , traits >
{
public :
typedef regex_constants :: syntax_option_type flag_type ;
typedef std :: ptrdiff_t difference_type ;
typedef std :: size_t size_type ;
typedef typename traits :: locale_type locale_type ;
typedef const charT * const_iterator ;

basic_regex_implementation ( ) { }
basic_regex_implementation ( const :: boost :: shared_ptr <
:: boost :: regex_traits_wrapper < traits > > & t )
: regex_data < charT , traits > ( t ) { }
void assign ( const charT * arg_first ,
const charT * arg_last ,
flag_type f )
{
regex_data < charT , traits > * pdat = this ;
basic_regex_parser < charT , traits > parser ( pdat ) ;
parser . parse ( arg_first , arg_last , f ) ;
}

locale_type imbue ( locale_type l )
{
return this -> m_ptraits -> imbue ( l ) ;
}
locale_type getloc ( ) const
{
return this -> m_ptraits -> getloc ( ) ;
}
std :: basic_string < charT > str ( ) const
{
std :: basic_string < charT > result ;
if ( this -> m_status == 0 )
result = std :: basic_string < charT > ( this -> m_expression , this -> m_expression_len ) ;
return result ;
}
const_iterator expression ( ) const
{
return this -> m_expression ;
}
std :: pair < const_iterator , const_iterator > subexpression ( std :: size_t n ) const
{
if ( n == 0 )
boost :: throw_exception ( std :: out_of_range ( "0 is not a valid subexpression index." ) ) ;
const std :: pair < std :: size_t , std :: size_t > & pi = this -> m_subs . at ( n - 1 ) ;
std :: pair < const_iterator , const_iterator > p ( expression ( ) + pi . first , expression ( ) + pi . second ) ;
return p ;
}


const_iterator begin ( ) const
{
return ( this -> m_status ? 0 : this -> m_expression ) ;
}
const_iterator end ( ) const
{
return ( this -> m_status ? 0 : this -> m_expression + this -> m_expression_len ) ;
}
flag_type flags ( ) const
{
return this -> m_flags ;
}
size_type size ( ) const
{
return this -> m_expression_len ;
}
int status ( ) const
{
return this -> m_status ;
}
size_type mark_count ( ) const
{
return this -> m_mark_count ;
}
const re_detail :: re_syntax_base * get_first_state ( ) const
{
return this -> m_first_state ;
}
unsigned get_restart_type ( ) const
{
return this -> m_restart_type ;
}
const unsigned char * get_map ( ) const
{
return this -> m_startmap ;
}
const :: boost :: regex_traits_wrapper < traits > & get_traits ( ) const
{
return * ( this -> m_ptraits ) ;
}
bool can_be_null ( ) const
{
return this -> m_can_be_null ;
}
const regex_data < charT , traits > & get_data ( ) const
{
basic_regex_implementation < charT , traits > const * p = this ;
return * static_cast < const regex_data < charT , traits > * > ( p ) ;
}
} ;

}
#308
template < class charT , class traits >

class basic_regex : public regbase
{
public :

typedef std :: size_t traits_size_type ;
typedef typename traits :: string_type traits_string_type ;
typedef charT char_type ;
typedef traits traits_type ;

typedef charT value_type ;
typedef charT & reference ;
typedef const charT & const_reference ;
typedef const charT * const_iterator ;
typedef const_iterator iterator ;
typedef std :: ptrdiff_t difference_type ;
typedef std :: size_t size_type ;
typedef regex_constants :: syntax_option_type flag_type ;



typedef typename traits :: locale_type locale_type ;

public :
explicit basic_regex ( ) { }
explicit basic_regex ( const charT * p , flag_type f = regex_constants :: normal )
{
assign ( p , f ) ;
}
basic_regex ( const charT * p1 , const charT * p2 , flag_type f = regex_constants :: normal )
{
assign ( p1 , p2 , f ) ;
}
basic_regex ( const charT * p , size_type len , flag_type f )
{
assign ( p , len , f ) ;
}
basic_regex ( const basic_regex & that )
: m_pimpl ( that . m_pimpl ) { }
~ basic_regex ( ) { }
basic_regex & operator = ( const basic_regex & that )
{
return assign ( that ) ;
}
basic_regex & operator = ( const charT * ptr )
{
return assign ( ptr ) ;
}



basic_regex & assign ( const basic_regex & that )
{
m_pimpl = that . m_pimpl ;
return * this ;
}
basic_regex & assign ( const charT * p , flag_type f = regex_constants :: normal )
{
return assign ( p , p + traits :: length ( p ) , f ) ;
}
basic_regex & assign ( const charT * p , size_type len , flag_type f )
{
return assign ( p , p + len , f ) ;
}
private :
basic_regex & do_assign ( const charT * p1 ,
const charT * p2 ,
flag_type f ) ;
public :
basic_regex & assign ( const charT * p1 ,
const charT * p2 ,
flag_type f = regex_constants :: normal )
{
return do_assign ( p1 , p2 , f ) ;
}


template < class ST , class SA >
unsigned int set_expression ( const std :: basic_string < charT , ST , SA > & p , flag_type f = regex_constants :: normal
#387
)
{
return set_expression ( p . data ( ) , p . data ( ) + p . size ( ) , f ) ;
}

template < class ST , class SA >
explicit basic_regex ( const std :: basic_string < charT , ST , SA > & p , flag_type f = regex_constants :: normal )
{
assign ( p , f ) ;
}

template < class InputIterator >
basic_regex ( InputIterator arg_first , InputIterator arg_last , flag_type f = regex_constants :: normal )
{
typedef typename traits :: string_type seq_type ;
seq_type a ( arg_first , arg_last ) ;
if ( a . size ( ) )
assign ( static_cast < const charT * > ( & * a . begin ( ) ) , static_cast < const charT * > ( & * a . begin ( ) + a . size
#404
( ) ) , f ) ;
else
assign ( static_cast < const charT * > ( 0 ) , static_cast < const charT * > ( 0 ) , f ) ;
}

template < class ST , class SA >
basic_regex & operator = ( const std :: basic_string < charT , ST , SA > & p )
{
return assign ( p . data ( ) , p . data ( ) + p . size ( ) , regex_constants :: normal ) ;
}

template < class string_traits , class A >
basic_regex & assign (
const std :: basic_string < charT , string_traits , A > & s ,
flag_type f = regex_constants :: normal )
{
return assign ( s . data ( ) , s . data ( ) + s . size ( ) , f ) ;
}

template < class InputIterator >
basic_regex & assign ( InputIterator arg_first ,
InputIterator arg_last ,
flag_type f = regex_constants :: normal )
{
typedef typename traits :: string_type seq_type ;
seq_type a ( arg_first , arg_last ) ;
if ( a . size ( ) )
{
const charT * p1 = & * a . begin ( ) ;
const charT * p2 = & * a . begin ( ) + a . size ( ) ;
return assign ( p1 , p2 , f ) ;
}
return assign ( static_cast < const charT * > ( 0 ) , static_cast < const charT * > ( 0 ) , f ) ;
}
#465
locale_type imbue ( locale_type l ) ;
locale_type getloc ( ) const
{
return m_pimpl . get ( ) ? m_pimpl -> getloc ( ) : locale_type ( ) ;
}




flag_type getflags ( ) const
{
return flags ( ) ;
}
flag_type flags ( ) const
{
return m_pimpl . get ( ) ? m_pimpl -> flags ( ) : 0 ;
}


std :: basic_string < charT > str ( ) const
{
return m_pimpl . get ( ) ? m_pimpl -> str ( ) : std :: basic_string < charT > ( ) ;
}


std :: pair < const_iterator , const_iterator > subexpression ( std :: size_t n ) const
{
if ( ! m_pimpl . get ( ) )
boost :: throw_exception ( std :: logic_error ( "Can't access subexpressions in an invalid regex." ) ) ;
return m_pimpl -> subexpression ( n ) ;
}
const_iterator begin ( ) const
{
return ( m_pimpl . get ( ) ? m_pimpl -> begin ( ) : 0 ) ;
}
const_iterator end ( ) const
{
return ( m_pimpl . get ( ) ? m_pimpl -> end ( ) : 0 ) ;
}


void swap ( basic_regex & that ) throw ( )
{
m_pimpl . swap ( that . m_pimpl ) ;
}


size_type size ( ) const
{
return ( m_pimpl . get ( ) ? m_pimpl -> size ( ) : 0 ) ;
}


size_type max_size ( ) const
{
return 4294967295U ;
}


bool empty ( ) const
{
return ( m_pimpl . get ( ) ? 0 != m_pimpl -> status ( ) : true ) ;
}

size_type mark_count ( ) const
{
return ( m_pimpl . get ( ) ? m_pimpl -> mark_count ( ) : 0 ) ;
}

int status ( ) const
{
return ( m_pimpl . get ( ) ? m_pimpl -> status ( ) : regex_constants :: error_empty ) ;
}

int compare ( const basic_regex & that ) const
{
if ( m_pimpl . get ( ) == that . m_pimpl . get ( ) )
return 0 ;
if ( ! m_pimpl . get ( ) )
return - 1 ;
if ( ! that . m_pimpl . get ( ) )
return 1 ;
if ( status ( ) != that . status ( ) )
return status ( ) - that . status ( ) ;
if ( flags ( ) != that . flags ( ) )
return flags ( ) - that . flags ( ) ;
return str ( ) . compare ( that . str ( ) ) ;
}
bool operator == ( const basic_regex & e ) const
{
return compare ( e ) == 0 ;
}
bool operator != ( const basic_regex & e ) const
{
return compare ( e ) != 0 ;
}
bool operator < ( const basic_regex & e ) const
{
return compare ( e ) < 0 ;
}
bool operator > ( const basic_regex & e ) const
{
return compare ( e ) > 0 ;
}
bool operator <= ( const basic_regex & e ) const
{
return compare ( e ) <= 0 ;
}
bool operator >= ( const basic_regex & e ) const
{
return compare ( e ) >= 0 ;
}




const charT * expression ( ) const
{
return ( m_pimpl . get ( ) && ! m_pimpl -> status ( ) ? m_pimpl -> expression ( ) : 0 ) ;
}
unsigned int set_expression ( const charT * p1 , const charT * p2 , flag_type f = regex_constants :: normal )
{
assign ( p1 , p2 , f | regex_constants :: no_except ) ;
return status ( ) ;
}
unsigned int set_expression ( const charT * p , flag_type f = regex_constants :: normal )
{
assign ( p , f | regex_constants :: no_except ) ;
return status ( ) ;
}
unsigned int error_code ( ) const
{
return status ( ) ;
}



const re_detail :: re_syntax_base * get_first_state ( ) const
{
( ( void ) 0 ) ;
return m_pimpl -> get_first_state ( ) ;
}
unsigned get_restart_type ( ) const
{
( ( void ) 0 ) ;
return m_pimpl -> get_restart_type ( ) ;
}
const unsigned char * get_map ( ) const
{
( ( void ) 0 ) ;
return m_pimpl -> get_map ( ) ;
}
const :: boost :: regex_traits_wrapper < traits > & get_traits ( ) const
{
( ( void ) 0 ) ;
return m_pimpl -> get_traits ( ) ;
}
bool can_be_null ( ) const
{
( ( void ) 0 ) ;
return m_pimpl -> can_be_null ( ) ;
}
const re_detail :: regex_data < charT , traits > & get_data ( ) const
{
( ( void ) 0 ) ;
return m_pimpl -> get_data ( ) ;
}
boost :: shared_ptr < re_detail :: named_subexpressions > get_named_subs ( ) const
{
return m_pimpl ;
}

private :
shared_ptr < re_detail :: basic_regex_implementation < charT , traits > > m_pimpl ;
} ;
#647
template < class charT , class traits >
basic_regex < charT , traits > & basic_regex < charT , traits > :: do_assign ( const charT * p1 ,
const charT * p2 ,
flag_type f )
{
shared_ptr < re_detail :: basic_regex_implementation < charT , traits > > temp ;
if ( ! m_pimpl . get ( ) )
{
temp = shared_ptr < re_detail :: basic_regex_implementation < charT , traits > > ( new re_detail :: basic_regex_implementation
#655
< charT , traits > ( ) ) ;
}
else
{
temp = shared_ptr < re_detail :: basic_regex_implementation < charT , traits > > ( new re_detail :: basic_regex_implementation
#659
< charT , traits > ( m_pimpl -> m_ptraits ) ) ;
}
temp -> assign ( p1 , p2 , f ) ;
temp . swap ( m_pimpl ) ;
return * this ;
}

template < class charT , class traits >
typename basic_regex < charT , traits > :: locale_type basic_regex < charT , traits > :: imbue ( locale_type l )
{
shared_ptr < re_detail :: basic_regex_implementation < charT , traits > > temp ( new re_detail :: basic_regex_implementation
#669
< charT , traits > ( ) ) ;
locale_type result = temp -> imbue ( l ) ;
temp . swap ( m_pimpl ) ;
return result ;
}




template < class charT , class traits >
void swap ( basic_regex < charT , traits > & e1 , basic_regex < charT , traits > & e2 )
{
e1 . swap ( e2 ) ;
}


template < class charT , class traits , class traits2 >
std :: basic_ostream < charT , traits > &
operator << ( std :: basic_ostream < charT , traits > & os ,
const basic_regex < charT , traits2 > & e )
{
return ( os << e . str ( ) ) ;
}
#708
template < class charT , class traits >

class reg_expression : public basic_regex < charT , traits >
{
public :
typedef typename basic_regex < charT , traits > :: flag_type flag_type ;
typedef typename basic_regex < charT , traits > :: size_type size_type ;
explicit reg_expression ( ) { }
explicit reg_expression ( const charT * p , flag_type f = regex_constants :: normal )
: basic_regex < charT , traits > ( p , f ) { }
reg_expression ( const charT * p1 , const charT * p2 , flag_type f = regex_constants :: normal )
: basic_regex < charT , traits > ( p1 , p2 , f ) { }
reg_expression ( const charT * p , size_type len , flag_type f )
: basic_regex < charT , traits > ( p , len , f ) { }
reg_expression ( const reg_expression & that )
: basic_regex < charT , traits > ( that ) { }
~ reg_expression ( ) { }
reg_expression & operator = ( const reg_expression & that )
{
return this -> assign ( that ) ;
}


template < class ST , class SA >
explicit reg_expression ( const std :: basic_string < charT , ST , SA > & p , flag_type f = regex_constants :: normal )
: basic_regex < charT , traits > ( p , f )
{
}

template < class InputIterator >
reg_expression ( InputIterator arg_first , InputIterator arg_last , flag_type f = regex_constants :: normal )
: basic_regex < charT , traits > ( arg_first , arg_last , f )
{
}

template < class ST , class SA >
reg_expression & operator = ( const std :: basic_string < charT , ST , SA > & p )
{
this -> assign ( p ) ;
return * this ;
}
#762
} ;





}
#1 "./boost/regex/v4/basic_regex_creator.hpp"
#39
namespace boost {

namespace re_detail {

template < class charT >
struct digraph : public std :: pair < charT , charT >
{
digraph ( ) : std :: pair < charT , charT > ( 0 , 0 ) { }
digraph ( charT c1 ) : std :: pair < charT , charT > ( c1 , 0 ) { }
digraph ( charT c1 , charT c2 ) : std :: pair < charT , charT > ( c1 , c2 )
{ }

digraph ( const digraph < charT > & d ) : std :: pair < charT , charT > ( d . first , d . second ) { }

template < class Seq >
digraph ( const Seq & s ) : std :: pair < charT , charT > ( )
{
( ( void ) 0 ) ;
( ( void ) 0 ) ;
this -> first = s [ 0 ] ;
this -> second = ( s . size ( ) > 1 ) ? s [ 1 ] : 0 ;
}
} ;

template < class charT , class traits >
class basic_char_set
{
public :
typedef digraph < charT > digraph_type ;
typedef typename traits :: string_type string_type ;
typedef typename traits :: char_class_type m_type ;

basic_char_set ( )
{
m_negate = false ;
m_has_digraphs = false ;
m_classes = 0 ;
m_negated_classes = 0 ;
m_empty = true ;
}

void add_single ( const digraph_type & s )
{
m_singles . insert ( m_singles . end ( ) , s ) ;
if ( s . second )
m_has_digraphs = true ;
m_empty = false ;
}
void add_range ( const digraph_type & first , const digraph_type & end )
{
m_ranges . insert ( m_ranges . end ( ) , first ) ;
m_ranges . insert ( m_ranges . end ( ) , end ) ;
if ( first . second )
{
m_has_digraphs = true ;
add_single ( first ) ;
}
if ( end . second )
{
m_has_digraphs = true ;
add_single ( end ) ;
}
m_empty = false ;
}
void add_class ( m_type m )
{
m_classes |= m ;
m_empty = false ;
}
void add_negated_class ( m_type m )
{
m_negated_classes |= m ;
m_empty = false ;
}
void add_equivalent ( const digraph_type & s )
{
m_equivalents . insert ( m_equivalents . end ( ) , s ) ;
if ( s . second )
{
m_has_digraphs = true ;
add_single ( s ) ;
}
m_empty = false ;
}
void negate ( )
{
m_negate = true ;

}




bool has_digraphs ( ) const
{
return m_has_digraphs ;
}
bool is_negated ( ) const
{
return m_negate ;
}
typedef typename std :: vector < digraph_type > :: const_iterator list_iterator ;
list_iterator singles_begin ( ) const
{
return m_singles . begin ( ) ;
}
list_iterator singles_end ( ) const
{
return m_singles . end ( ) ;
}
list_iterator ranges_begin ( ) const
{
return m_ranges . begin ( ) ;
}
list_iterator ranges_end ( ) const
{
return m_ranges . end ( ) ;
}
list_iterator equivalents_begin ( ) const
{
return m_equivalents . begin ( ) ;
}
list_iterator equivalents_end ( ) const
{
return m_equivalents . end ( ) ;
}
m_type classes ( ) const
{
return m_classes ;
}
m_type negated_classes ( ) const
{
return m_negated_classes ;
}
bool empty ( ) const
{
return m_empty ;
}
private :
std :: vector < digraph_type > m_singles ;
std :: vector < digraph_type > m_ranges ;
bool m_negate ;
bool m_has_digraphs ;
m_type m_classes ;
m_type m_negated_classes ;
bool m_empty ;
std :: vector < digraph_type > m_equivalents ;
} ;

template < class charT , class traits >
class basic_regex_creator
{
public :
basic_regex_creator ( regex_data < charT , traits > * data ) ;
std :: ptrdiff_t getoffset ( void * addr )
{
return getoffset ( addr , m_pdata -> m_data . data ( ) ) ;
}
std :: ptrdiff_t getoffset ( const void * addr , const void * base )
{
return static_cast < const char * > ( addr ) - static_cast < const char * > ( base ) ;
}
re_syntax_base * getaddress ( std :: ptrdiff_t off )
{
return getaddress ( off , m_pdata -> m_data . data ( ) ) ;
}
re_syntax_base * getaddress ( std :: ptrdiff_t off , void * base )
{
return static_cast < re_syntax_base * > ( static_cast < void * > ( static_cast < char * > ( base ) + off ) ) ;
}
void init ( unsigned l_flags )
{
m_pdata -> m_flags = l_flags ;
m_icase = l_flags & regex_constants :: icase ;
}
regbase :: flag_type flags ( )
{
return m_pdata -> m_flags ;
}
void flags ( regbase :: flag_type f )
{
m_pdata -> m_flags = f ;
if ( m_icase != static_cast < bool > ( f & regbase :: icase ) )
{
m_icase = static_cast < bool > ( f & regbase :: icase ) ;
}
}
re_syntax_base * append_state ( syntax_element_type t , std :: size_t s = sizeof ( re_syntax_base ) ) ;
re_syntax_base * insert_state ( std :: ptrdiff_t pos , syntax_element_type t , std :: size_t s = sizeof ( re_syntax_base
#227
) ) ;
re_literal * append_literal ( charT c ) ;
re_syntax_base * append_set ( const basic_char_set < charT , traits > & char_set ) ;
re_syntax_base * append_set ( const basic_char_set < charT , traits > & char_set , mpl :: false_ * ) ;
re_syntax_base * append_set ( const basic_char_set < charT , traits > & char_set , mpl :: true_ * ) ;
void finalize ( const charT * p1 , const charT * p2 ) ;
protected :
regex_data < charT , traits > * m_pdata ;
const :: boost :: regex_traits_wrapper < traits > &
m_traits ;
re_syntax_base * m_last_state ;
bool m_icase ;
unsigned m_repeater_id ;
bool m_has_backrefs ;
unsigned m_backrefs ;
boost :: uintmax_t m_bad_repeats ;
bool m_has_recursions ;
std :: vector < bool > m_recursion_checks ;
typename traits :: char_class_type m_word_mask ;
typename traits :: char_class_type m_mask_space ;
typename traits :: char_class_type m_lower_mask ;
typename traits :: char_class_type m_upper_mask ;
typename traits :: char_class_type m_alpha_mask ;
private :
basic_regex_creator & operator = ( const basic_regex_creator & ) ;
basic_regex_creator ( const basic_regex_creator & ) ;

void fixup_pointers ( re_syntax_base * state ) ;
void fixup_recursions ( re_syntax_base * state ) ;
void create_startmaps ( re_syntax_base * state ) ;
int calculate_backstep ( re_syntax_base * state ) ;
void create_startmap ( re_syntax_base * state , unsigned char * l_map , unsigned int * pnull , unsigned char mask ) ;
unsigned get_restart_type ( re_syntax_base * state ) ;
void set_all_masks ( unsigned char * bits , unsigned char ) ;
bool is_bad_repeat ( re_syntax_base * pt ) ;
void set_bad_repeat ( re_syntax_base * pt ) ;
syntax_element_type get_repeat_type ( re_syntax_base * state ) ;
void probe_leading_repeat ( re_syntax_base * state ) ;
} ;

template < class charT , class traits >
basic_regex_creator < charT , traits > :: basic_regex_creator ( regex_data < charT , traits > * data )
: m_pdata ( data ) , m_traits ( * ( data -> m_ptraits ) ) , m_last_state ( 0 ) , m_repeater_id ( 0 ) , m_has_backrefs ( false
#269
) , m_backrefs ( 0 ) , m_has_recursions ( false )
{
m_pdata -> m_data . clear ( ) ;
m_pdata -> m_status = :: boost :: regex_constants :: error_ok ;
static const charT w = 'w' ;
static const charT s = 's' ;
static const charT l [ 5 ] = { 'l' , 'o' , 'w' , 'e' , 'r' , } ;
static const charT u [ 5 ] = { 'u' , 'p' , 'p' , 'e' , 'r' , } ;
static const charT a [ 5 ] = { 'a' , 'l' , 'p' , 'h' , 'a' , } ;
m_word_mask = m_traits . lookup_classname ( & w , & w + 1 ) ;
m_mask_space = m_traits . lookup_classname ( & s , & s + 1 ) ;
m_lower_mask = m_traits . lookup_classname ( l , l + 5 ) ;
m_upper_mask = m_traits . lookup_classname ( u , u + 5 ) ;
m_alpha_mask = m_traits . lookup_classname ( a , a + 5 ) ;
m_pdata -> m_word_mask = m_word_mask ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
}

template < class charT , class traits >
re_syntax_base * basic_regex_creator < charT , traits > :: append_state ( syntax_element_type t , std :: size_t s )
{

if ( t == syntax_element_backref )
this -> m_has_backrefs = true ;

m_pdata -> m_data . align ( ) ;

if ( m_last_state )
m_last_state -> next . i = m_pdata -> m_data . size ( ) - getoffset ( m_last_state ) ;

m_last_state = static_cast < re_syntax_base * > ( m_pdata -> m_data . extend ( s ) ) ;

m_last_state -> next . i = 0 ;
m_last_state -> type = t ;
return m_last_state ;
}

template < class charT , class traits >
re_syntax_base * basic_regex_creator < charT , traits > :: insert_state ( std :: ptrdiff_t pos , syntax_element_type t ,
#311
std :: size_t s )
{

m_pdata -> m_data . align ( ) ;

if ( m_last_state )
m_last_state -> next . i = m_pdata -> m_data . size ( ) - getoffset ( m_last_state ) ;

std :: ptrdiff_t off = getoffset ( m_last_state ) + s ;

re_syntax_base * new_state = static_cast < re_syntax_base * > ( m_pdata -> m_data . insert ( pos , s ) ) ;

new_state -> next . i = s ;
new_state -> type = t ;
m_last_state = getaddress ( off ) ;
return new_state ;
}

template < class charT , class traits >
re_literal * basic_regex_creator < charT , traits > :: append_literal ( charT c )
{
re_literal * result ;

if ( ( 0 == m_last_state ) || ( m_last_state -> type != syntax_element_literal ) )
{

result = static_cast < re_literal * > ( append_state ( syntax_element_literal , sizeof ( re_literal ) + sizeof ( charT )
#337
) ) ;
result -> length = 1 ;
* static_cast < charT * > ( static_cast < void * > ( result + 1 ) ) = m_traits . translate ( c , m_icase ) ;
}
else
{

std :: ptrdiff_t off = getoffset ( m_last_state ) ;
m_pdata -> m_data . extend ( sizeof ( charT ) ) ;
m_last_state = result = static_cast < re_literal * > ( getaddress ( off ) ) ;
charT * characters = static_cast < charT * > ( static_cast < void * > ( result + 1 ) ) ;
characters [ result -> length ] = m_traits . translate ( c , m_icase ) ;
++ ( result -> length ) ;
}
return result ;
}

template < class charT , class traits >
inline re_syntax_base * basic_regex_creator < charT , traits > :: append_set (
const basic_char_set < charT , traits > & char_set )
{
typedef mpl :: bool_ < ( sizeof ( charT ) == 1 ) > truth_type ;
return char_set . has_digraphs ( )
? append_set ( char_set , static_cast < mpl :: false_ * > ( 0 ) )
: append_set ( char_set , static_cast < truth_type * > ( 0 ) ) ;
}

template < class charT , class traits >
re_syntax_base * basic_regex_creator < charT , traits > :: append_set (
const basic_char_set < charT , traits > & char_set , mpl :: false_ * )
{
typedef typename traits :: string_type string_type ;
typedef typename basic_char_set < charT , traits > :: list_iterator item_iterator ;
typedef typename traits :: char_class_type m_type ;

re_set_long < m_type > * result = static_cast < re_set_long < m_type > * > ( append_state ( syntax_element_long_set , sizeof
#372
( re_set_long < m_type > ) ) ) ;



result -> csingles = static_cast < unsigned int > ( :: boost :: re_detail :: distance ( char_set . singles_begin ( ) , char_set
#376
. singles_end ( ) ) ) ;
result -> cranges = static_cast < unsigned int > ( :: boost :: re_detail :: distance ( char_set . ranges_begin ( ) , char_set
#377
. ranges_end ( ) ) ) / 2 ;
result -> cequivalents = static_cast < unsigned int > ( :: boost :: re_detail :: distance ( char_set . equivalents_begin
#378
( ) , char_set . equivalents_end ( ) ) ) ;
result -> cclasses = char_set . classes ( ) ;
result -> cnclasses = char_set . negated_classes ( ) ;
if ( flags ( ) & regbase :: icase )
{

if ( ( ( result -> cclasses & m_lower_mask ) == m_lower_mask ) || ( ( result -> cclasses & m_upper_mask ) == m_upper_mask
#384
) )
result -> cclasses |= m_alpha_mask ;
if ( ( ( result -> cnclasses & m_lower_mask ) == m_lower_mask ) || ( ( result -> cnclasses & m_upper_mask ) == m_upper_mask
#386
) )
result -> cnclasses |= m_alpha_mask ;
}

result -> isnot = char_set . is_negated ( ) ;
result -> singleton = ! char_set . has_digraphs ( ) ;



std :: ptrdiff_t offset = getoffset ( result ) ;



item_iterator first , last ;
first = char_set . singles_begin ( ) ;
last = char_set . singles_end ( ) ;
while ( first != last )
{
charT * p = static_cast < charT * > ( this -> m_pdata -> m_data . extend ( sizeof ( charT ) * ( first -> second ? 3 : 2 )
#404
) ) ;
p [ 0 ] = m_traits . translate ( first -> first , m_icase ) ;
if ( first -> second )
{
p [ 1 ] = m_traits . translate ( first -> second , m_icase ) ;
p [ 2 ] = 0 ;
}
else
p [ 1 ] = 0 ;
++ first ;
}



first = char_set . ranges_begin ( ) ;
last = char_set . ranges_end ( ) ;
while ( first != last )
{

digraph < charT > c1 = * first ;
c1 . first = this -> m_traits . translate ( c1 . first , this -> m_icase ) ;
c1 . second = this -> m_traits . translate ( c1 . second , this -> m_icase ) ;
++ first ;
digraph < charT > c2 = * first ;
c2 . first = this -> m_traits . translate ( c2 . first , this -> m_icase ) ;
c2 . second = this -> m_traits . translate ( c2 . second , this -> m_icase ) ;
++ first ;
string_type s1 , s2 ;

if ( flags ( ) & regex_constants :: collate )
{
#445
charT a1 [ 3 ] = { c1 . first , c1 . second , charT ( 0 ) , } ;
charT a2 [ 3 ] = { c2 . first , c2 . second , charT ( 0 ) , } ;
s1 = this -> m_traits . transform ( a1 , ( a1 [ 1 ] ? a1 + 2 : a1 + 1 ) ) ;
s2 = this -> m_traits . transform ( a2 , ( a2 [ 1 ] ? a2 + 2 : a2 + 1 ) ) ;

if ( s1 . size ( ) == 0 )
s1 = string_type ( 1 , charT ( 0 ) ) ;
if ( s2 . size ( ) == 0 )
s2 = string_type ( 1 , charT ( 0 ) ) ;
}
else
{
if ( c1 . second )
{
s1 . insert ( s1 . end ( ) , c1 . first ) ;
s1 . insert ( s1 . end ( ) , c1 . second ) ;
}
else
s1 = string_type ( 1 , c1 . first ) ;
if ( c2 . second )
{
s2 . insert ( s2 . end ( ) , c2 . first ) ;
s2 . insert ( s2 . end ( ) , c2 . second ) ;
}
else
s2 . insert ( s2 . end ( ) , c2 . first ) ;
}
if ( s1 > s2 )
{

return 0 ;
}
charT * p = static_cast < charT * > ( this -> m_pdata -> m_data . extend ( sizeof ( charT ) * ( s1 . size ( ) + s2 . size
#477
( ) + 2 ) ) ) ;
re_detail :: copy ( s1 . begin ( ) , s1 . end ( ) , p ) ;
p [ s1 . size ( ) ] = charT ( 0 ) ;
p += s1 . size ( ) + 1 ;
re_detail :: copy ( s2 . begin ( ) , s2 . end ( ) , p ) ;
p [ s2 . size ( ) ] = charT ( 0 ) ;
}



first = char_set . equivalents_begin ( ) ;
last = char_set . equivalents_end ( ) ;
while ( first != last )
{
string_type s ;
if ( first -> second )
{
#500
charT cs [ 3 ] = { first -> first , first -> second , charT ( 0 ) , } ;
s = m_traits . transform_primary ( cs , cs + 2 ) ;

}
else
s = m_traits . transform_primary ( & first -> first , & first -> first + 1 ) ;
if ( s . empty ( ) )
return 0 ;
charT * p = static_cast < charT * > ( this -> m_pdata -> m_data . extend ( sizeof ( charT ) * ( s . size ( ) + 1 ) ) ) ;
#508

re_detail :: copy ( s . begin ( ) , s . end ( ) , p ) ;
p [ s . size ( ) ] = charT ( 0 ) ;
++ first ;
}



m_last_state = result = static_cast < re_set_long < m_type > * > ( getaddress ( offset ) ) ;
return result ;
}

template < class T >
inline bool char_less ( T t1 , T t2 )
{
return t1 < t2 ;
}
inline bool char_less ( char t1 , char t2 )
{
return static_cast < unsigned char > ( t1 ) < static_cast < unsigned char > ( t2 ) ;
}
inline bool char_less ( signed char t1 , signed char t2 )
{
return static_cast < unsigned char > ( t1 ) < static_cast < unsigned char > ( t2 ) ;
}

template < class charT , class traits >
re_syntax_base * basic_regex_creator < charT , traits > :: append_set (
const basic_char_set < charT , traits > & char_set , mpl :: true_ * )
{
typedef typename traits :: string_type string_type ;
typedef typename basic_char_set < charT , traits > :: list_iterator item_iterator ;

re_set * result = static_cast < re_set * > ( append_state ( syntax_element_set , sizeof ( re_set ) ) ) ;
bool negate = char_set . is_negated ( ) ;
std :: memset ( result -> _map , 0 , sizeof ( result -> _map ) ) ;



item_iterator first , last ;
first = char_set . singles_begin ( ) ;
last = char_set . singles_end ( ) ;
while ( first != last )
{
for ( unsigned int i = 0 ; i < ( 1 << 8 ) ; ++ i )
{
if ( this -> m_traits . translate ( static_cast < charT > ( i ) , this -> m_icase )
== this -> m_traits . translate ( first -> first , this -> m_icase ) )
result -> _map [ i ] = true ;
}
++ first ;
}



first = char_set . ranges_begin ( ) ;
last = char_set . ranges_end ( ) ;
while ( first != last )
{

charT c1 = this -> m_traits . translate ( first -> first , this -> m_icase ) ;
++ first ;
charT c2 = this -> m_traits . translate ( first -> first , this -> m_icase ) ;
++ first ;

if ( flags ( ) & regex_constants :: collate )
{

charT c3 [ 2 ] = { c1 , charT ( 0 ) , } ;
string_type s1 = this -> m_traits . transform ( c3 , c3 + 1 ) ;
c3 [ 0 ] = c2 ;
string_type s2 = this -> m_traits . transform ( c3 , c3 + 1 ) ;
if ( s1 > s2 )
{

return 0 ;
}
( ( void ) 0 ) ;
for ( unsigned i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
c3 [ 0 ] = static_cast < charT > ( i ) ;
string_type s3 = this -> m_traits . transform ( c3 , c3 + 1 ) ;
if ( ( s1 <= s3 ) && ( s3 <= s2 ) )
result -> _map [ i ] = true ;
}
}
else
{
if ( char_less ( c2 , c1 ) )
{

return 0 ;
}

std :: memset ( result -> _map + static_cast < unsigned char > ( c1 ) , true , 1 + static_cast < unsigned char > ( c2 ) -
#602
static_cast < unsigned char > ( c1 ) ) ;
}
}



typedef typename traits :: char_class_type m_type ;
m_type m = char_set . classes ( ) ;
if ( flags ( ) & regbase :: icase )
{

if ( ( ( m & m_lower_mask ) == m_lower_mask ) || ( ( m & m_upper_mask ) == m_upper_mask ) )
m |= m_alpha_mask ;
}
if ( m != 0 )
{
for ( unsigned i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
if ( this -> m_traits . isctype ( static_cast < charT > ( i ) , m ) )
result -> _map [ i ] = true ;
}
}



m = char_set . negated_classes ( ) ;
if ( flags ( ) & regbase :: icase )
{

if ( ( ( m & m_lower_mask ) == m_lower_mask ) || ( ( m & m_upper_mask ) == m_upper_mask ) )
m |= m_alpha_mask ;
}
if ( m != 0 )
{
for ( unsigned i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
if ( 0 == this -> m_traits . isctype ( static_cast < charT > ( i ) , m ) )
result -> _map [ i ] = true ;
}
}



first = char_set . equivalents_begin ( ) ;
last = char_set . equivalents_end ( ) ;
while ( first != last )
{
string_type s ;
( ( void ) 0 ) ;
s = m_traits . transform_primary ( & first -> first , & first -> first + 1 ) ;
if ( s . empty ( ) )
return 0 ;
for ( unsigned i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
charT c [ 2 ] = { ( static_cast < charT > ( i ) ) , charT ( 0 ) , } ;
string_type s2 = this -> m_traits . transform_primary ( c , c + 1 ) ;
if ( s == s2 )
result -> _map [ i ] = true ;
}
++ first ;
}
if ( negate )
{
for ( unsigned i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
result -> _map [ i ] = ! ( result -> _map [ i ] ) ;
}
}
return result ;
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: finalize ( const charT * p1 , const charT * p2 )
{
if ( this -> m_pdata -> m_status )
return ;


append_state ( syntax_element_match ) ;

std :: ptrdiff_t len = p2 - p1 ;
m_pdata -> m_expression_len = len ;
charT * ps = static_cast < charT * > ( m_pdata -> m_data . extend ( sizeof ( charT ) * ( 1 + ( p2 - p1 ) ) ) ) ;
m_pdata -> m_expression = ps ;
re_detail :: copy ( p1 , p2 , ps ) ;
ps [ p2 - p1 ] = 0 ;


m_pdata -> m_status = 0 ;

m_pdata -> m_first_state = static_cast < re_syntax_base * > ( m_pdata -> m_data . data ( ) ) ;

fixup_pointers ( m_pdata -> m_first_state ) ;
if ( m_has_recursions )
{
m_pdata -> m_has_recursions = true ;
fixup_recursions ( m_pdata -> m_first_state ) ;
if ( this -> m_pdata -> m_status )
return ;
}
else
m_pdata -> m_has_recursions = false ;

create_startmaps ( m_pdata -> m_first_state ) ;

std :: memset ( m_pdata -> m_startmap , 0 , sizeof ( m_pdata -> m_startmap ) ) ;
m_pdata -> m_can_be_null = 0 ;

m_bad_repeats = 0 ;
if ( m_has_recursions )
m_recursion_checks . assign ( 1 + m_pdata -> m_mark_count , false ) ;
create_startmap ( m_pdata -> m_first_state , m_pdata -> m_startmap , & ( m_pdata -> m_can_be_null ) , mask_all ) ;

m_pdata -> m_restart_type = get_restart_type ( m_pdata -> m_first_state ) ;

probe_leading_repeat ( m_pdata -> m_first_state ) ;
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: fixup_pointers ( re_syntax_base * state )
{
while ( state )
{
switch ( state -> type )
{
case syntax_element_recurse :
m_has_recursions = true ;
if ( state -> next . i )
state -> next . p = getaddress ( state -> next . i , state ) ;
else
state -> next . p = 0 ;
break ;
case syntax_element_rep :
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_long_set_rep :

static_cast < re_repeat * > ( state ) -> state_id = m_repeater_id ++ ;
( ( void ) 0 ) ;
case syntax_element_alt :
std :: memset ( static_cast < re_alt * > ( state ) -> _map , 0 , sizeof ( static_cast < re_alt * > ( state ) -> _map ) )
#743
;
static_cast < re_alt * > ( state ) -> can_be_null = 0 ;
( ( void ) 0 ) ;
case syntax_element_jump :
static_cast < re_jump * > ( state ) -> alt . p = getaddress ( static_cast < re_jump * > ( state ) -> alt . i , state ) ;
#747

( ( void ) 0 ) ;
default :
if ( state -> next . i )
state -> next . p = getaddress ( state -> next . i , state ) ;
else
state -> next . p = 0 ;
}
state = state -> next . p ;
}
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: fixup_recursions ( re_syntax_base * state )
{
re_syntax_base * base = state ;
while ( state )
{
switch ( state -> type )
{
case syntax_element_assert_backref :
{

int idx = static_cast < const re_brace * > ( state ) -> index ;
if ( idx < 0 )
{
idx = - idx - 1 ;
if ( idx >= 10000 )
{
idx = m_pdata -> get_id ( idx ) ;
if ( idx <= 0 )
{

if ( 0 == this -> m_pdata -> m_status )
this -> m_pdata -> m_status = boost :: regex_constants :: error_bad_pattern ;



this -> m_pdata -> m_expression = 0 ;
this -> m_pdata -> m_expression_len = 0 ;



if ( 0 == ( this -> flags ( ) & regex_constants :: no_except ) )
{
std :: string message = "Encountered a forward reference to a marked sub-expression that does not exist." ;
boost :: regex_error e ( message , boost :: regex_constants :: error_bad_pattern , 0 ) ;
e . raise ( ) ;
}
}
}
}
}
break ;
case syntax_element_recurse :
{
bool ok = false ;
re_syntax_base * p = base ;
std :: ptrdiff_t idx = static_cast < re_jump * > ( state ) -> alt . i ;
if ( idx > 10000 )
{




idx = m_pdata -> get_id ( static_cast < int > ( idx ) ) ;
}
while ( p )
{
if ( ( p -> type == syntax_element_startmark ) && ( static_cast < re_brace * > ( p ) -> index == idx ) )
{



static_cast < re_jump * > ( state ) -> alt . p = p ;
ok = true ;



p = p -> next . p ;
int next_rep_id = 0 ;
while ( p )
{
switch ( p -> type )
{
case syntax_element_rep :
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_long_set_rep :
next_rep_id = static_cast < re_repeat * > ( p ) -> state_id ;
break ;
case syntax_element_endmark :
if ( static_cast < const re_brace * > ( p ) -> index == idx )
next_rep_id = - 1 ;
break ;
default :
break ;
}
if ( next_rep_id )
break ;
p = p -> next . p ;
}
if ( next_rep_id > 0 )
{
static_cast < re_recurse * > ( state ) -> state_id = next_rep_id - 1 ;
}

break ;
}
p = p -> next . p ;
}
if ( ! ok )
{

if ( 0 == this -> m_pdata -> m_status )
this -> m_pdata -> m_status = boost :: regex_constants :: error_bad_pattern ;



this -> m_pdata -> m_expression = 0 ;
this -> m_pdata -> m_expression_len = 0 ;



if ( 0 == ( this -> flags ( ) & regex_constants :: no_except ) )
{
std :: string message = "Encountered a forward reference to a recursive sub-expression that does not exist." ;
boost :: regex_error e ( message , boost :: regex_constants :: error_bad_pattern , 0 ) ;
e . raise ( ) ;
}
}
}
break ;
default :
break ;
}
state = state -> next . p ;
}
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: create_startmaps ( re_syntax_base * state )
{
#899
bool l_icase = m_icase ;
std :: vector < std :: pair < bool , re_syntax_base * > > v ;

while ( state )
{
switch ( state -> type )
{
case syntax_element_toggle_case :

m_icase = static_cast < re_case * > ( state ) -> icase ;
state = state -> next . p ;
continue ;
case syntax_element_alt :
case syntax_element_rep :
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_long_set_rep :

v . push_back ( std :: pair < bool , re_syntax_base * > ( m_icase , state ) ) ;
state = state -> next . p ;
break ;
case syntax_element_backstep :

static_cast < re_brace * > ( state ) -> index
= this -> calculate_backstep ( state -> next . p ) ;
if ( static_cast < re_brace * > ( state ) -> index < 0 )
{

if ( 0 == this -> m_pdata -> m_status )
this -> m_pdata -> m_status = boost :: regex_constants :: error_bad_pattern ;



this -> m_pdata -> m_expression = 0 ;
this -> m_pdata -> m_expression_len = 0 ;



if ( 0 == ( this -> flags ( ) & regex_constants :: no_except ) )
{
std :: string message = "Invalid lookbehind assertion encountered in the regular expression." ;
boost :: regex_error e ( message , boost :: regex_constants :: error_bad_pattern , 0 ) ;
e . raise ( ) ;
}
}
( ( void ) 0 ) ;
default :
state = state -> next . p ;
}
}


while ( v . size ( ) )
{

if ( m_has_recursions )
m_recursion_checks . assign ( 1 + m_pdata -> m_mark_count , false ) ;

const std :: pair < bool , re_syntax_base * > & p = v . back ( ) ;
m_icase = p . first ;
state = p . second ;
v . pop_back ( ) ;


m_bad_repeats = 0 ;
create_startmap ( state -> next . p , static_cast < re_alt * > ( state ) -> _map , & static_cast < re_alt * > ( state ) ->
#965
can_be_null , mask_take ) ;
m_bad_repeats = 0 ;

if ( m_has_recursions )
m_recursion_checks . assign ( 1 + m_pdata -> m_mark_count , false ) ;
create_startmap ( static_cast < re_alt * > ( state ) -> alt . p , static_cast < re_alt * > ( state ) -> _map , & static_cast
#970
< re_alt * > ( state ) -> can_be_null , mask_skip ) ;

state -> type = this -> get_repeat_type ( state ) ;
}

m_icase = l_icase ;
}

template < class charT , class traits >
int basic_regex_creator < charT , traits > :: calculate_backstep ( re_syntax_base * state )
{
typedef typename traits :: char_class_type m_type ;
int result = 0 ;
while ( state )
{
switch ( state -> type )
{
case syntax_element_startmark :
if ( ( static_cast < re_brace * > ( state ) -> index == - 1 )
|| ( static_cast < re_brace * > ( state ) -> index == - 2 ) )
{
state = static_cast < re_jump * > ( state -> next . p ) -> alt . p -> next . p ;
continue ;
}
else if ( static_cast < re_brace * > ( state ) -> index == - 3 )
{
state = state -> next . p -> next . p ;
continue ;
}
break ;
case syntax_element_endmark :
if ( ( static_cast < re_brace * > ( state ) -> index == - 1 )
|| ( static_cast < re_brace * > ( state ) -> index == - 2 ) )
return result ;
break ;
case syntax_element_literal :
result += static_cast < re_literal * > ( state ) -> length ;
break ;
case syntax_element_wild :
case syntax_element_set :
result += 1 ;
break ;
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_backref :
case syntax_element_rep :
case syntax_element_combining :
case syntax_element_long_set_rep :
case syntax_element_backstep :
{
re_repeat * rep = static_cast < re_repeat * > ( state ) ;

state -> type = this -> get_repeat_type ( state ) ;
if ( ( state -> type == syntax_element_dot_rep )
|| ( state -> type == syntax_element_char_rep )
|| ( state -> type == syntax_element_short_set_rep ) )
{
if ( rep -> max != rep -> min )
return - 1 ;
result += static_cast < int > ( rep -> min ) ;
state = rep -> alt . p ;
continue ;
}
else if ( state -> type == syntax_element_long_set_rep )
{
( ( void ) 0 ) ;
if ( static_cast < re_set_long < m_type > * > ( rep -> next . p ) -> singleton == 0 )
return - 1 ;
if ( rep -> max != rep -> min )
return - 1 ;
result += static_cast < int > ( rep -> min ) ;
state = rep -> alt . p ;
continue ;
}
}
return - 1 ;
case syntax_element_long_set :
if ( static_cast < re_set_long < m_type > * > ( state ) -> singleton == 0 )
return - 1 ;
result += 1 ;
break ;
case syntax_element_jump :
state = static_cast < re_jump * > ( state ) -> alt . p ;
continue ;
case syntax_element_alt :
{
int r1 = calculate_backstep ( state -> next . p ) ;
int r2 = calculate_backstep ( static_cast < re_alt * > ( state ) -> alt . p ) ;
if ( ( r1 < 0 ) || ( r1 != r2 ) )
return - 1 ;
return result + r1 ;
}
default :
break ;
}
state = state -> next . p ;
}
return - 1 ;
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: create_startmap ( re_syntax_base * state , unsigned char * l_map , unsigned
#1072
int * pnull , unsigned char mask )
{
int not_last_jump = 1 ;
re_syntax_base * recursion_start = 0 ;
int recursion_sub = 0 ;
re_syntax_base * recursion_restart = 0 ;


bool l_icase = m_icase ;

while ( state )
{
switch ( state -> type )
{
case syntax_element_toggle_case :
l_icase = static_cast < re_case * > ( state ) -> icase ;
state = state -> next . p ;
break ;
case syntax_element_literal :
{


if ( l_map )
{
l_map [ 0 ] |= mask_init ;
charT first_char = * static_cast < charT * > ( static_cast < void * > ( static_cast < re_literal * > ( state ) + 1 ) ) ;
#1097

for ( unsigned int i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
if ( m_traits . translate ( static_cast < charT > ( i ) , l_icase ) == first_char )
l_map [ i ] |= mask ;
}
}
return ;
}
case syntax_element_end_line :
{

if ( l_map )
{
l_map [ 0 ] |= mask_init ;
l_map [ static_cast < unsigned > ( '\n' ) ] |= mask ;
l_map [ static_cast < unsigned > ( '\r' ) ] |= mask ;
l_map [ static_cast < unsigned > ( '\f' ) ] |= mask ;
l_map [ 0x85 ] |= mask ;
}

if ( pnull )
create_startmap ( state -> next . p , 0 , pnull , mask ) ;
return ;
}
case syntax_element_recurse :
{
if ( state -> type == syntax_element_startmark )
recursion_sub = static_cast < re_brace * > ( state ) -> index ;
else
recursion_sub = 0 ;
if ( m_recursion_checks [ recursion_sub ] )
{

if ( 0 == this -> m_pdata -> m_status )
this -> m_pdata -> m_status = boost :: regex_constants :: error_bad_pattern ;



this -> m_pdata -> m_expression = 0 ;
this -> m_pdata -> m_expression_len = 0 ;



if ( 0 == ( this -> flags ( ) & regex_constants :: no_except ) )
{
std :: string message = "Encountered an infinite recursion." ;
boost :: regex_error e ( message , boost :: regex_constants :: error_bad_pattern , 0 ) ;
e . raise ( ) ;
}
}
else if ( recursion_start == 0 )
{
recursion_start = state ;
recursion_restart = state -> next . p ;
state = static_cast < re_jump * > ( state ) -> alt . p ;
m_recursion_checks [ recursion_sub ] = true ;
break ;
}
m_recursion_checks [ recursion_sub ] = true ;

( ( void ) 0 ) ;
}
case syntax_element_backref :

if ( pnull )
* pnull |= mask ;
( ( void ) 0 ) ;
case syntax_element_wild :
{

set_all_masks ( l_map , mask ) ;
return ;
}
case syntax_element_match :
{

set_all_masks ( l_map , mask ) ;
if ( pnull )
* pnull |= mask ;
return ;
}
case syntax_element_word_start :
{

create_startmap ( state -> next . p , l_map , pnull , mask ) ;
if ( l_map )
{
l_map [ 0 ] |= mask_init ;
for ( unsigned int i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
if ( ! m_traits . isctype ( static_cast < charT > ( i ) , m_word_mask ) )
l_map [ i ] &= static_cast < unsigned char > ( ~ mask ) ;
}
}
return ;
}
case syntax_element_word_end :
{

create_startmap ( state -> next . p , l_map , pnull , mask ) ;
if ( l_map )
{
l_map [ 0 ] |= mask_init ;
for ( unsigned int i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
if ( m_traits . isctype ( static_cast < charT > ( i ) , m_word_mask ) )
l_map [ i ] &= static_cast < unsigned char > ( ~ mask ) ;
}
}
return ;
}
case syntax_element_buffer_end :
{

if ( pnull )
* pnull |= mask ;
return ;
}
case syntax_element_long_set :
if ( l_map )
{
typedef typename traits :: char_class_type m_type ;
if ( static_cast < re_set_long < m_type > * > ( state ) -> singleton )
{
l_map [ 0 ] |= mask_init ;
for ( unsigned int i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
charT c = static_cast < charT > ( i ) ;
if ( & c != re_is_set_member ( & c , & c + 1 , static_cast < re_set_long < m_type > * > ( state ) , * m_pdata , l_icase )
#1226
)
l_map [ i ] |= mask ;
}
}
else
set_all_masks ( l_map , mask ) ;
}
return ;
case syntax_element_set :
if ( l_map )
{
l_map [ 0 ] |= mask_init ;
for ( unsigned int i = 0 ; i < ( 1u << 8 ) ; ++ i )
{
if ( static_cast < re_set * > ( state ) -> _map [
static_cast < unsigned char > ( m_traits . translate ( static_cast < charT > ( i ) , l_icase ) ) ] )
l_map [ i ] |= mask ;
}
}
return ;
case syntax_element_jump :

state = static_cast < re_alt * > ( state ) -> alt . p ;
not_last_jump = - 1 ;
break ;
case syntax_element_alt :
case syntax_element_rep :
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_long_set_rep :
{
re_alt * rep = static_cast < re_alt * > ( state ) ;
if ( rep -> _map [ 0 ] & mask_init )
{
if ( l_map )
{

l_map [ 0 ] |= mask_init ;
for ( unsigned int i = 0 ; i <= 255 ; ++ i )
{
if ( rep -> _map [ i ] & mask_any )
l_map [ i ] |= mask ;
}
}
if ( pnull )
{
if ( rep -> can_be_null & mask_any )
* pnull |= mask ;
}
}
else
{


if ( is_bad_repeat ( state ) )
{
set_all_masks ( l_map , mask ) ;
if ( pnull )
* pnull |= mask ;
return ;
}
set_bad_repeat ( state ) ;
create_startmap ( state -> next . p , l_map , pnull , mask ) ;
if ( ( state -> type == syntax_element_alt )
|| ( static_cast < re_repeat * > ( state ) -> min == 0 )
|| ( not_last_jump == 0 ) )
create_startmap ( rep -> alt . p , l_map , pnull , mask ) ;
}
}
return ;
case syntax_element_soft_buffer_end :

if ( l_map )
{
l_map [ 0 ] |= mask_init ;
l_map [ static_cast < unsigned > ( '\n' ) ] |= mask ;
l_map [ static_cast < unsigned > ( '\r' ) ] |= mask ;
}
if ( pnull )
* pnull |= mask ;
return ;
case syntax_element_endmark :

if ( static_cast < re_brace * > ( state ) -> index < 0 )
{

set_all_masks ( l_map , mask ) ;
if ( pnull )
* pnull |= mask ;
return ;
}
else if ( recursion_start && ( recursion_sub != 0 ) && ( recursion_sub == static_cast < re_brace * > ( state ) -> index )
#1318
)
{

recursion_start = 0 ;
state = recursion_restart ;
break ;
}
#1332
if ( m_pdata -> m_has_recursions && static_cast < re_brace * > ( state ) -> index )
{
bool ok = false ;
re_syntax_base * p = m_pdata -> m_first_state ;
while ( p )
{
if ( p -> type == syntax_element_recurse )
{
re_brace * p2 = static_cast < re_brace * > ( static_cast < re_jump * > ( p ) -> alt . p ) ;
if ( ( p2 -> type == syntax_element_startmark ) && ( p2 -> index == static_cast < re_brace * > ( state ) -> index ) )
{
ok = true ;
break ;
}
}
p = p -> next . p ;
}
if ( ok )
{
create_startmap ( p -> next . p , l_map , pnull , mask ) ;
}
}
state = state -> next . p ;
break ;

case syntax_element_startmark :

if ( static_cast < re_brace * > ( state ) -> index == - 3 )
{
state = state -> next . p -> next . p ;
break ;
}
( ( void ) 0 ) ;
default :
state = state -> next . p ;
}
++ not_last_jump ;
}
}

template < class charT , class traits >
unsigned basic_regex_creator < charT , traits > :: get_restart_type ( re_syntax_base * state )
{



while ( state )
{
switch ( state -> type )
{
case syntax_element_startmark :
case syntax_element_endmark :
state = state -> next . p ;
continue ;
case syntax_element_start_line :
return regbase :: restart_line ;
case syntax_element_word_start :
return regbase :: restart_word ;
case syntax_element_buffer_start :
return regbase :: restart_buf ;
case syntax_element_restart_continue :
return regbase :: restart_continue ;
default :
state = 0 ;
continue ;
}
}
return regbase :: restart_any ;
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: set_all_masks ( unsigned char * bits , unsigned char mask )
{





if ( bits )
{
if ( bits [ 0 ] == 0 )
( std :: memset ) ( bits , mask , 1u << 8 ) ;
else
{
for ( unsigned i = 0 ; i < ( 1u << 8 ) ; ++ i )
bits [ i ] |= mask ;
}
bits [ 0 ] |= mask_init ;
}
}

template < class charT , class traits >
bool basic_regex_creator < charT , traits > :: is_bad_repeat ( re_syntax_base * pt )
{
switch ( pt -> type )
{
case syntax_element_rep :
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_long_set_rep :
{
unsigned state_id = static_cast < re_repeat * > ( pt ) -> state_id ;
if ( state_id > sizeof ( m_bad_repeats ) * 8 )
return true ;
static const boost :: uintmax_t one = 1uL ;
return m_bad_repeats & ( one << state_id ) ;
}
default :
return false ;
}
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: set_bad_repeat ( re_syntax_base * pt )
{
switch ( pt -> type )
{
case syntax_element_rep :
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_long_set_rep :
{
unsigned state_id = static_cast < re_repeat * > ( pt ) -> state_id ;
static const boost :: uintmax_t one = 1uL ;
if ( state_id <= sizeof ( m_bad_repeats ) * 8 )
m_bad_repeats |= ( one << state_id ) ;
}
break ;
default :
break ;
}
}

template < class charT , class traits >
syntax_element_type basic_regex_creator < charT , traits > :: get_repeat_type ( re_syntax_base * state )
{
typedef typename traits :: char_class_type m_type ;
if ( state -> type == syntax_element_rep )
{

if ( state -> next . p -> next . p -> next . p == static_cast < re_alt * > ( state ) -> alt . p )
{
switch ( state -> next . p -> type )
{
case re_detail :: syntax_element_wild :
return re_detail :: syntax_element_dot_rep ;
case re_detail :: syntax_element_literal :
return re_detail :: syntax_element_char_rep ;
case re_detail :: syntax_element_set :
return re_detail :: syntax_element_short_set_rep ;
case re_detail :: syntax_element_long_set :
if ( static_cast < re_detail :: re_set_long < m_type > * > ( state -> next . p ) -> singleton )
return re_detail :: syntax_element_long_set_rep ;
break ;
default :
break ;
}
}
}
return state -> type ;
}

template < class charT , class traits >
void basic_regex_creator < charT , traits > :: probe_leading_repeat ( re_syntax_base * state )
{


do
{
switch ( state -> type )
{
case syntax_element_startmark :
if ( static_cast < re_brace * > ( state ) -> index >= 0 )
{
state = state -> next . p ;
continue ;
}
if ( ( static_cast < re_brace * > ( state ) -> index == - 1 )
|| ( static_cast < re_brace * > ( state ) -> index == - 2 ) )
{

state = static_cast < const re_jump * > ( state -> next . p ) -> alt . p -> next . p ;
continue ;
}
if ( static_cast < re_brace * > ( state ) -> index == - 3 )
{

state = state -> next . p -> next . p ;
continue ;
}
return ;
case syntax_element_endmark :
case syntax_element_start_line :
case syntax_element_end_line :
case syntax_element_word_boundary :
case syntax_element_within_word :
case syntax_element_word_start :
case syntax_element_word_end :
case syntax_element_buffer_start :
case syntax_element_buffer_end :
case syntax_element_restart_continue :
state = state -> next . p ;
break ;
case syntax_element_dot_rep :
case syntax_element_char_rep :
case syntax_element_short_set_rep :
case syntax_element_long_set_rep :
if ( this -> m_has_backrefs == 0 )
static_cast < re_repeat * > ( state ) -> leading = true ;
( ( void ) 0 ) ;
default :
return ;
}
} while ( state ) ;
}


}

}
#1 "./boost/regex/v4/basic_regex_parser.hpp"
#33
namespace boost {
namespace re_detail {
#41
template < class charT , class traits >
class basic_regex_parser : public basic_regex_creator < charT , traits >
{
public :
basic_regex_parser ( regex_data < charT , traits > * data ) ;
void parse ( const charT * p1 , const charT * p2 , unsigned flags ) ;
void fail ( regex_constants :: error_type error_code , std :: ptrdiff_t position ) ;
void fail ( regex_constants :: error_type error_code , std :: ptrdiff_t position , std :: string message , std :: ptrdiff_t
#48
start_pos ) ;
void fail ( regex_constants :: error_type error_code , std :: ptrdiff_t position , const std :: string & message )
{
fail ( error_code , position , message , position ) ;
}

bool parse_all ( ) ;
bool parse_basic ( ) ;
bool parse_extended ( ) ;
bool parse_literal ( ) ;
bool parse_open_paren ( ) ;
bool parse_basic_escape ( ) ;
bool parse_extended_escape ( ) ;
bool parse_match_any ( ) ;
bool parse_repeat ( std :: size_t low = 0 , std :: size_t high = ( std :: numeric_limits < std :: size_t > :: max ) ( ) )
#62
;
bool parse_repeat_range ( bool isbasic ) ;
bool parse_alt ( ) ;
bool parse_set ( ) ;
bool parse_backref ( ) ;
void parse_set_literal ( basic_char_set < charT , traits > & char_set ) ;
bool parse_inner_set ( basic_char_set < charT , traits > & char_set ) ;
bool parse_QE ( ) ;
bool parse_perl_extension ( ) ;
bool add_emacs_code ( bool negate ) ;
bool unwind_alts ( std :: ptrdiff_t last_paren_start ) ;
digraph < charT > get_next_set_literal ( basic_char_set < charT , traits > & char_set ) ;
charT unescape_character ( ) ;
regex_constants :: syntax_option_type parse_options ( ) ;

private :
typedef bool ( basic_regex_parser :: * parser_proc_type ) ( ) ;
typedef typename traits :: string_type string_type ;
typedef typename traits :: char_class_type char_class_type ;
parser_proc_type m_parser_proc ;
const charT * m_base ;
const charT * m_end ;
const charT * m_position ;
unsigned m_mark_count ;
int m_mark_reset ;
unsigned m_max_mark ;
std :: ptrdiff_t m_paren_start ;
std :: ptrdiff_t m_alt_insert_point ;
bool m_has_case_change ;
#97
std :: vector < std :: ptrdiff_t > m_alt_jumps ;


basic_regex_parser & operator = ( const basic_regex_parser & ) ;
basic_regex_parser ( const basic_regex_parser & ) ;
} ;

template < class charT , class traits >
basic_regex_parser < charT , traits > :: basic_regex_parser ( regex_data < charT , traits > * data )
: basic_regex_creator < charT , traits > ( data ) , m_mark_count ( 0 ) , m_mark_reset ( - 1 ) , m_max_mark ( 0 ) , m_paren_start
#106
( 0 ) , m_alt_insert_point ( 0 ) , m_has_case_change ( false )
{
}

template < class charT , class traits >
void basic_regex_parser < charT , traits > :: parse ( const charT * p1 , const charT * p2 , unsigned l_flags )
{

this -> init ( l_flags ) ;

m_position = m_base = p1 ;
m_end = p2 ;

if ( ( p1 == p2 ) &&
(
( ( l_flags & regbase :: main_option_type ) != regbase :: perl_syntax_group )
|| ( l_flags & regbase :: no_empty_expressions )
)
)
{
fail ( regex_constants :: error_empty , 0 ) ;
return ;
}

switch ( l_flags & regbase :: main_option_type )
{
case regbase :: perl_syntax_group :
{
m_parser_proc = & basic_regex_parser < charT , traits > :: parse_extended ;



re_brace * br = static_cast < re_brace * > ( this -> append_state ( syntax_element_startmark , sizeof ( re_brace ) ) ) ;
#138

br -> index = 0 ;
br -> icase = this -> flags ( ) & regbase :: icase ;
break ;
}
case regbase :: basic_syntax_group :
m_parser_proc = & basic_regex_parser < charT , traits > :: parse_basic ;
break ;
case regbase :: literal :
m_parser_proc = & basic_regex_parser < charT , traits > :: parse_literal ;
break ;
default :


fail ( regex_constants :: error_unknown , 0 , "An invalid combination of regular expression syntax flags was used." ) ;
return ;
}


bool result = parse_all ( ) ;



unwind_alts ( - 1 ) ;

this -> flags ( l_flags ) ;


if ( ! result )
{
fail ( regex_constants :: error_paren , :: boost :: re_detail :: distance ( m_base , m_position ) , "Found a closing ) with no corresponding openening parenthesis."
#168
) ;
return ;
}

if ( this -> m_pdata -> m_status )
return ;

this -> m_pdata -> m_mark_count = 1 + m_mark_count ;
this -> finalize ( p1 , p2 ) ;
}

template < class charT , class traits >
void basic_regex_parser < charT , traits > :: fail ( regex_constants :: error_type error_code , std :: ptrdiff_t position
#180
)
{

std :: string message = this -> m_pdata -> m_ptraits -> error_string ( error_code ) ;
fail ( error_code , position , message ) ;
}

template < class charT , class traits >
void basic_regex_parser < charT , traits > :: fail ( regex_constants :: error_type error_code , std :: ptrdiff_t position
#188
, std :: string message , std :: ptrdiff_t start_pos )
{
if ( 0 == this -> m_pdata -> m_status )
this -> m_pdata -> m_status = error_code ;
m_position = m_end ;





if ( start_pos == position )
start_pos = ( std :: max ) ( static_cast < std :: ptrdiff_t > ( 0 ) , position - static_cast < std :: ptrdiff_t > ( 10 )
#199
) ;
std :: ptrdiff_t end_pos = ( std :: min ) ( position + static_cast < std :: ptrdiff_t > ( 10 ) , static_cast < std :: ptrdiff_t
#200
> ( m_end - m_base ) ) ;
if ( error_code != regex_constants :: error_empty )
{
if ( ( start_pos != 0 ) || ( end_pos != ( m_end - m_base ) ) )
message += "  The error occurred while parsing the regular expression fragment: '" ;
else
message += "  The error occurred while parsing the regular expression: '" ;
if ( start_pos != end_pos )
{
message += std :: string ( m_base + start_pos , m_base + position ) ;
message += ">>>HERE>>>" ;
message += std :: string ( m_base + position , m_base + end_pos ) ;
}
message += "'." ;
}



if ( 0 == ( this -> flags ( ) & regex_constants :: no_except ) )
{
boost :: regex_error e ( message , error_code , position ) ;
e . raise ( ) ;
}



}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_all ( )
{
bool result = true ;
while ( result && ( m_position != m_end ) )
{
result = ( this ->* m_parser_proc ) ( ) ;
}
return result ;
}





template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_basic ( )
{
switch ( this -> m_traits . syntax_type ( * m_position ) )
{
case regex_constants :: syntax_escape :
return parse_basic_escape ( ) ;
case regex_constants :: syntax_dot :
return parse_match_any ( ) ;
case regex_constants :: syntax_caret :
++ m_position ;
this -> append_state ( syntax_element_start_line ) ;
break ;
case regex_constants :: syntax_dollar :
++ m_position ;
this -> append_state ( syntax_element_end_line ) ;
break ;
case regex_constants :: syntax_star :
if ( ! ( this -> m_last_state ) || ( this -> m_last_state -> type == syntax_element_start_line ) )
return parse_literal ( ) ;
else
{
++ m_position ;
return parse_repeat ( ) ;
}
case regex_constants :: syntax_plus :
if ( ! ( this -> m_last_state ) || ( this -> m_last_state -> type == syntax_element_start_line ) || ! ( this -> flags ( )
#269
& regbase :: emacs_ex ) )
return parse_literal ( ) ;
else
{
++ m_position ;
return parse_repeat ( 1 ) ;
}
case regex_constants :: syntax_question :
if ( ! ( this -> m_last_state ) || ( this -> m_last_state -> type == syntax_element_start_line ) || ! ( this -> flags ( )
#277
& regbase :: emacs_ex ) )
return parse_literal ( ) ;
else
{
++ m_position ;
return parse_repeat ( 0 , 1 ) ;
}
case regex_constants :: syntax_open_set :
return parse_set ( ) ;
case regex_constants :: syntax_newline :
if ( this -> flags ( ) & regbase :: newline_alt )
return parse_alt ( ) ;
else
return parse_literal ( ) ;
default :
return parse_literal ( ) ;
}
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_extended ( )
{
bool result = true ;
switch ( this -> m_traits . syntax_type ( * m_position ) )
{
case regex_constants :: syntax_open_mark :
return parse_open_paren ( ) ;
case regex_constants :: syntax_close_mark :
return false ;
case regex_constants :: syntax_escape :
return parse_extended_escape ( ) ;
case regex_constants :: syntax_dot :
return parse_match_any ( ) ;
case regex_constants :: syntax_caret :
++ m_position ;
this -> append_state (
( this -> flags ( ) & regex_constants :: no_mod_m ? syntax_element_buffer_start : syntax_element_start_line ) ) ;
break ;
case regex_constants :: syntax_dollar :
++ m_position ;
this -> append_state (
( this -> flags ( ) & regex_constants :: no_mod_m ? syntax_element_buffer_end : syntax_element_end_line ) ) ;
break ;
case regex_constants :: syntax_star :
if ( m_position == this -> m_base )
{
fail ( regex_constants :: error_badrepeat , 0 , "The repeat operator \"*\" cannot start a regular expression." ) ;
return false ;
}
++ m_position ;
return parse_repeat ( ) ;
case regex_constants :: syntax_question :
if ( m_position == this -> m_base )
{
fail ( regex_constants :: error_badrepeat , 0 , "The repeat operator \"?\" cannot start a regular expression." ) ;
return false ;
}
++ m_position ;
return parse_repeat ( 0 , 1 ) ;
case regex_constants :: syntax_plus :
if ( m_position == this -> m_base )
{
fail ( regex_constants :: error_badrepeat , 0 , "The repeat operator \"+\" cannot start a regular expression." ) ;
return false ;
}
++ m_position ;
return parse_repeat ( 1 ) ;
case regex_constants :: syntax_open_brace :
++ m_position ;
return parse_repeat_range ( false ) ;
case regex_constants :: syntax_close_brace :
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , "Found a closing repetition operator } with no corresponding {."
#349
) ;
return false ;
case regex_constants :: syntax_or :
return parse_alt ( ) ;
case regex_constants :: syntax_open_set :
return parse_set ( ) ;
case regex_constants :: syntax_newline :
if ( this -> flags ( ) & regbase :: newline_alt )
return parse_alt ( ) ;
else
return parse_literal ( ) ;
case regex_constants :: syntax_hash :




if ( ( this -> flags ( )
& ( regbase :: no_perl_ex | regbase :: mod_x ) )
== regbase :: mod_x )
{
while ( ( m_position != m_end ) && ! is_separator ( * m_position ++ ) ) { }
return true ;
}
( ( void ) 0 ) ;
default :
result = parse_literal ( ) ;
break ;
}
return result ;
}




template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_literal ( )
{


if (
( ( this -> flags ( )
& ( regbase :: main_option_type | regbase :: mod_x | regbase :: no_perl_ex ) )
!= regbase :: mod_x )
|| ! this -> m_traits . isctype ( * m_position , this -> m_mask_space ) )
this -> append_literal ( * m_position ) ;
++ m_position ;
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_open_paren ( )
{



if ( ++ m_position == m_end )
{
fail ( regex_constants :: error_paren , m_position - m_base ) ;
return false ;
}



if (
( ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) ) == 0 )
|| ( ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: emacs_ex ) ) == ( regbase :: basic_syntax_group | regbase
#414
:: emacs_ex ) )
)
{
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_question )
return parse_perl_extension ( ) ;
}



unsigned markid = 0 ;
if ( 0 == ( this -> flags ( ) & regbase :: nosubs ) )
{
markid = ++ m_mark_count ;

if ( this -> flags ( ) & regbase :: save_subexpression_location )
this -> m_pdata -> m_subs . push_back ( std :: pair < std :: size_t , std :: size_t > ( std :: distance ( m_base , m_position
#429
) - 1 , 0 ) ) ;




}
re_brace * pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_startmark , sizeof ( re_brace ) ) ) ;
#435

pb -> index = markid ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
std :: ptrdiff_t last_paren_start = this -> getoffset ( pb ) ;

std :: ptrdiff_t last_alt_point = m_alt_insert_point ;
this -> m_pdata -> m_data . align ( ) ;
m_alt_insert_point = this -> m_pdata -> m_data . size ( ) ;



regex_constants :: syntax_option_type opts = this -> flags ( ) ;
bool old_case_change = m_has_case_change ;
m_has_case_change = false ;



int mark_reset = m_mark_reset ;
m_mark_reset = - 1 ;




parse_all ( ) ;



if ( 0 == unwind_alts ( last_paren_start ) )
return false ;



if ( m_has_case_change )
{



static_cast < re_case * > (
this -> append_state ( syntax_element_toggle_case , sizeof ( re_case ) )
) -> icase = opts & regbase :: icase ;
}
this -> flags ( opts ) ;
m_has_case_change = old_case_change ;



m_mark_reset = mark_reset ;



if ( m_position == m_end )
{
this -> fail ( regex_constants :: error_paren , :: boost :: re_detail :: distance ( m_base , m_end ) ) ;
return false ;
}
( ( void ) 0 ) ;

if ( markid && ( this -> flags ( ) & regbase :: save_subexpression_location ) )
this -> m_pdata -> m_subs . at ( markid - 1 ) . second = std :: distance ( m_base , m_position ) ;




++ m_position ;



pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_endmark , sizeof ( re_brace ) ) ) ;
pb -> index = markid ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
this -> m_paren_start = last_paren_start ;



this -> m_alt_insert_point = last_alt_point ;



if ( ( markid > 0 ) && ( markid < sizeof ( unsigned ) * 8 ) )
this -> m_backrefs |= 1u << ( markid - 1 ) ;

return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_basic_escape ( )
{
++ m_position ;
bool result = true ;
switch ( this -> m_traits . escape_syntax_type ( * m_position ) )
{
case regex_constants :: syntax_open_mark :
return parse_open_paren ( ) ;
case regex_constants :: syntax_close_mark :
return false ;
case regex_constants :: syntax_plus :
if ( this -> flags ( ) & regex_constants :: bk_plus_qm )
{
++ m_position ;
return parse_repeat ( 1 ) ;
}
else
return parse_literal ( ) ;
case regex_constants :: syntax_question :
if ( this -> flags ( ) & regex_constants :: bk_plus_qm )
{
++ m_position ;
return parse_repeat ( 0 , 1 ) ;
}
else
return parse_literal ( ) ;
case regex_constants :: syntax_open_brace :
if ( this -> flags ( ) & regbase :: no_intervals )
return parse_literal ( ) ;
++ m_position ;
return parse_repeat_range ( true ) ;
case regex_constants :: syntax_close_brace :
if ( this -> flags ( ) & regbase :: no_intervals )
return parse_literal ( ) ;
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , "Found a closing repetition operator } with no corresponding {."
#554
) ;
return false ;
case regex_constants :: syntax_or :
if ( this -> flags ( ) & regbase :: bk_vbar )
return parse_alt ( ) ;
else
result = parse_literal ( ) ;
break ;
case regex_constants :: syntax_digit :
return parse_backref ( ) ;
case regex_constants :: escape_type_start_buffer :
if ( this -> flags ( ) & regbase :: emacs_ex )
{
++ m_position ;
this -> append_state ( syntax_element_buffer_start ) ;
}
else
result = parse_literal ( ) ;
break ;
case regex_constants :: escape_type_end_buffer :
if ( this -> flags ( ) & regbase :: emacs_ex )
{
++ m_position ;
this -> append_state ( syntax_element_buffer_end ) ;
}
else
result = parse_literal ( ) ;
break ;
case regex_constants :: escape_type_word_assert :
if ( this -> flags ( ) & regbase :: emacs_ex )
{
++ m_position ;
this -> append_state ( syntax_element_word_boundary ) ;
}
else
result = parse_literal ( ) ;
break ;
case regex_constants :: escape_type_not_word_assert :
if ( this -> flags ( ) & regbase :: emacs_ex )
{
++ m_position ;
this -> append_state ( syntax_element_within_word ) ;
}
else
result = parse_literal ( ) ;
break ;
case regex_constants :: escape_type_left_word :
if ( this -> flags ( ) & regbase :: emacs_ex )
{
++ m_position ;
this -> append_state ( syntax_element_word_start ) ;
}
else
result = parse_literal ( ) ;
break ;
case regex_constants :: escape_type_right_word :
if ( this -> flags ( ) & regbase :: emacs_ex )
{
++ m_position ;
this -> append_state ( syntax_element_word_end ) ;
}
else
result = parse_literal ( ) ;
break ;
default :
if ( this -> flags ( ) & regbase :: emacs_ex )
{
bool negate = true ;
switch ( * m_position )
{
case 'w' :
negate = false ;
( ( void ) 0 ) ;
case 'W' :
{
basic_char_set < charT , traits > char_set ;
if ( negate )
char_set . negate ( ) ;
char_set . add_class ( this -> m_word_mask ) ;
if ( 0 == this -> append_set ( char_set ) )
{
fail ( regex_constants :: error_ctype , m_position - m_base ) ;
return false ;
}
++ m_position ;
return true ;
}
case 's' :
negate = false ;
( ( void ) 0 ) ;
case 'S' :
return add_emacs_code ( negate ) ;
case 'c' :
case 'C' :

fail ( regex_constants :: error_escape , m_position - m_base , "The \\c and \\C escape sequences are not supported by POSIX basic regular expressions: try the Perl syntax instead."
#649
) ;
return false ;
default :
break ;
}
}
result = parse_literal ( ) ;
break ;
}
return result ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_extended_escape ( )
{
++ m_position ;
if ( m_position == m_end )
{
fail ( regex_constants :: error_escape , m_position - m_base , "Incomplete escape sequence found." ) ;
return false ;
}
bool negate = false ;
switch ( this -> m_traits . escape_syntax_type ( * m_position ) )
{
case regex_constants :: escape_type_not_class :
negate = true ;
( ( void ) 0 ) ;
case regex_constants :: escape_type_class :
{
escape_type_class_jump :
typedef typename traits :: char_class_type m_type ;
m_type m = this -> m_traits . lookup_classname ( m_position , m_position + 1 ) ;
if ( m != 0 )
{
basic_char_set < charT , traits > char_set ;
if ( negate )
char_set . negate ( ) ;
char_set . add_class ( m ) ;
if ( 0 == this -> append_set ( char_set ) )
{
fail ( regex_constants :: error_ctype , m_position - m_base ) ;
return false ;
}
++ m_position ;
return true ;
}



this -> append_literal ( unescape_character ( ) ) ;
break ;
}
case regex_constants :: syntax_digit :
return parse_backref ( ) ;
case regex_constants :: escape_type_left_word :
++ m_position ;
this -> append_state ( syntax_element_word_start ) ;
break ;
case regex_constants :: escape_type_right_word :
++ m_position ;
this -> append_state ( syntax_element_word_end ) ;
break ;
case regex_constants :: escape_type_start_buffer :
++ m_position ;
this -> append_state ( syntax_element_buffer_start ) ;
break ;
case regex_constants :: escape_type_end_buffer :
++ m_position ;
this -> append_state ( syntax_element_buffer_end ) ;
break ;
case regex_constants :: escape_type_word_assert :
++ m_position ;
this -> append_state ( syntax_element_word_boundary ) ;
break ;
case regex_constants :: escape_type_not_word_assert :
++ m_position ;
this -> append_state ( syntax_element_within_word ) ;
break ;
case regex_constants :: escape_type_Z :
++ m_position ;
this -> append_state ( syntax_element_soft_buffer_end ) ;
break ;
case regex_constants :: escape_type_Q :
return parse_QE ( ) ;
case regex_constants :: escape_type_C :
return parse_match_any ( ) ;
case regex_constants :: escape_type_X :
++ m_position ;
this -> append_state ( syntax_element_combining ) ;
break ;
case regex_constants :: escape_type_G :
++ m_position ;
this -> append_state ( syntax_element_restart_continue ) ;
break ;
case regex_constants :: escape_type_not_property :
negate = true ;
( ( void ) 0 ) ;
case regex_constants :: escape_type_property :
{
++ m_position ;
char_class_type m ;
if ( m_position == m_end )
{
fail ( regex_constants :: error_escape , m_position - m_base , "Incomplete property escape found." ) ;
return false ;
}

if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_open_brace )
{
const charT * base = m_position ;

while ( ( m_position != m_end ) && ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_brace
#760
) )
++ m_position ;
if ( m_position == m_end )
{
fail ( regex_constants :: error_escape , m_position - m_base , "Closing } missing from property escape sequence." ) ;
return false ;
}
m = this -> m_traits . lookup_classname ( ++ base , m_position ++ ) ;
}
else
{
m = this -> m_traits . lookup_classname ( m_position , m_position + 1 ) ;
++ m_position ;
}
if ( m != 0 )
{
basic_char_set < charT , traits > char_set ;
if ( negate )
char_set . negate ( ) ;
char_set . add_class ( m ) ;
if ( 0 == this -> append_set ( char_set ) )
{
fail ( regex_constants :: error_ctype , m_position - m_base ) ;
return false ;
}
return true ;
}
fail ( regex_constants :: error_ctype , m_position - m_base , "Escape sequence was neither a valid property nor a valid character class name."
#787
) ;
return false ;
}
case regex_constants :: escape_type_reset_start_mark :
if ( 0 == ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) ) )
{
re_brace * pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_startmark , sizeof ( re_brace ) ) ) ;
#793

pb -> index = - 5 ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
this -> m_pdata -> m_data . align ( ) ;
++ m_position ;
return true ;
}
goto escape_type_class_jump ;
case regex_constants :: escape_type_line_ending :
if ( 0 == ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) ) )
{
const charT * e = get_escape_R_string < charT > ( ) ;
const charT * old_position = m_position ;
const charT * old_end = m_end ;
const charT * old_base = m_base ;
m_position = e ;
m_base = e ;
m_end = e + traits :: length ( e ) ;
bool r = parse_all ( ) ;
m_position = ++ old_position ;
m_end = old_end ;
m_base = old_base ;
return r ;
}
goto escape_type_class_jump ;
case regex_constants :: escape_type_extended_backref :
if ( 0 == ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) ) )
{
bool have_brace = false ;
bool negative = false ;
static const char * incomplete_message = "Incomplete \\g escape found." ;
if ( ++ m_position == m_end )
{
fail ( regex_constants :: error_escape , m_position - m_base , incomplete_message ) ;
return false ;
}

regex_constants :: syntax_type syn = this -> m_traits . syntax_type ( * m_position ) ;
regex_constants :: syntax_type syn_end = 0 ;
if ( ( syn == regex_constants :: syntax_open_brace )
|| ( syn == regex_constants :: escape_type_left_word )
|| ( syn == regex_constants :: escape_type_end_buffer ) )
{
if ( ++ m_position == m_end )
{
fail ( regex_constants :: error_escape , m_position - m_base , incomplete_message ) ;
return false ;
}
have_brace = true ;
switch ( syn )
{
case regex_constants :: syntax_open_brace :
syn_end = regex_constants :: syntax_close_brace ;
break ;
case regex_constants :: escape_type_left_word :
syn_end = regex_constants :: escape_type_right_word ;
break ;
default :
syn_end = regex_constants :: escape_type_end_buffer ;
break ;
}
}
negative = ( * m_position == static_cast < charT > ( '-' ) ) ;
if ( ( negative ) && ( ++ m_position == m_end ) )
{
fail ( regex_constants :: error_escape , m_position - m_base , incomplete_message ) ;
return false ;
}
const charT * pc = m_position ;
int i = this -> m_traits . toi ( pc , m_end , 10 ) ;
if ( ( i < 0 ) && syn_end )
{

const charT * base = m_position ;
while ( ( m_position != m_end ) && ( this -> m_traits . syntax_type ( * m_position ) != syn_end ) )
{
++ m_position ;
}
i = hash_value_from_capture_name ( base , m_position ) ;
pc = m_position ;
}
if ( negative )
i = 1 + m_mark_count - i ;
if ( ( ( i > 0 ) && ( this -> m_backrefs & ( 1u << ( i - 1 ) ) ) ) || ( ( i > 10000 ) && ( this -> m_pdata -> get_id ( i
#876
) > 0 ) && ( this -> m_backrefs & ( 1u << ( this -> m_pdata -> get_id ( i ) - 1 ) ) ) ) )
{
m_position = pc ;
re_brace * pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_backref , sizeof ( re_brace ) ) ) ;
pb -> index = i ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
}
else
{
fail ( regex_constants :: error_backref , m_position - m_base ) ;
return false ;
}
m_position = pc ;
if ( have_brace )
{
if ( ( m_position == m_end ) || ( this -> m_traits . syntax_type ( * m_position ) != syn_end ) )
{
fail ( regex_constants :: error_escape , m_position - m_base , incomplete_message ) ;
return false ;
}
++ m_position ;
}
return true ;
}
goto escape_type_class_jump ;
case regex_constants :: escape_type_control_v :
if ( 0 == ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) ) )
goto escape_type_class_jump ;
( ( void ) 0 ) ;
default :
this -> append_literal ( unescape_character ( ) ) ;
break ;
}
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_match_any ( )
{



++ m_position ;
static_cast < re_dot * > (
this -> append_state ( syntax_element_wild , sizeof ( re_dot ) )
) -> mask = static_cast < unsigned char > ( this -> flags ( ) & regbase :: no_mod_s
? re_detail :: force_not_newline
: this -> flags ( ) & regbase :: mod_s ?
re_detail :: force_newline : re_detail :: dont_care ) ;
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_repeat ( std :: size_t low , std :: size_t high )
{
bool greedy = true ;
bool pocessive = false ;
std :: size_t insert_point ;



if ( ( m_position != m_end )
&& (
( 0 == ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) ) )
|| ( ( regbase :: basic_syntax_group | regbase :: emacs_ex ) == ( this -> flags ( ) & ( regbase :: main_option_type | regbase
#940
:: emacs_ex ) ) )
)
)
{

if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_question )
{
greedy = false ;
++ m_position ;
}

if ( ( m_position != m_end )
&& ( 0 == ( this -> flags ( ) & regbase :: main_option_type ) )
&& ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_plus ) )
{
pocessive = true ;
++ m_position ;
}
}
if ( 0 == this -> m_last_state )
{
fail ( regex_constants :: error_badrepeat , :: boost :: re_detail :: distance ( m_base , m_position ) , "Nothing to repeat."
#961
) ;
return false ;
}
if ( this -> m_last_state -> type == syntax_element_endmark )
{

insert_point = this -> m_paren_start ;
}
else if ( ( this -> m_last_state -> type == syntax_element_literal ) && ( static_cast < re_literal * > ( this -> m_last_state
#969
) -> length > 1 ) )
{

re_literal * lit = static_cast < re_literal * > ( this -> m_last_state ) ;
charT c = ( static_cast < charT * > ( static_cast < void * > ( lit + 1 ) ) ) [ lit -> length - 1 ] ;
-- ( lit -> length ) ;

lit = static_cast < re_literal * > ( this -> append_state ( syntax_element_literal , sizeof ( re_literal ) + sizeof ( charT
#976
) ) ) ;
lit -> length = 1 ;
( static_cast < charT * > ( static_cast < void * > ( lit + 1 ) ) ) [ 0 ] = c ;
insert_point = this -> getoffset ( this -> m_last_state ) ;
}
else
{

switch ( this -> m_last_state -> type )
{
case syntax_element_start_line :
case syntax_element_end_line :
case syntax_element_word_boundary :
case syntax_element_within_word :
case syntax_element_word_start :
case syntax_element_word_end :
case syntax_element_buffer_start :
case syntax_element_buffer_end :
case syntax_element_alt :
case syntax_element_soft_buffer_end :
case syntax_element_restart_continue :
case syntax_element_jump :
case syntax_element_startmark :
case syntax_element_backstep :

fail ( regex_constants :: error_badrepeat , m_position - m_base ) ;
return false ;
default :

break ;
}
insert_point = this -> getoffset ( this -> m_last_state ) ;
}



re_repeat * rep = static_cast < re_repeat * > ( this -> insert_state ( insert_point , syntax_element_rep , re_repeater_size
#1012
) ) ;
rep -> min = low ;
rep -> max = high ;
rep -> greedy = greedy ;
rep -> leading = false ;

std :: ptrdiff_t rep_off = this -> getoffset ( rep ) ;

re_jump * jmp = static_cast < re_jump * > ( this -> append_state ( syntax_element_jump , sizeof ( re_jump ) ) ) ;
jmp -> alt . i = rep_off - this -> getoffset ( jmp ) ;
this -> m_pdata -> m_data . align ( ) ;

rep = static_cast < re_repeat * > ( this -> getaddress ( rep_off ) ) ;
rep -> alt . i = this -> m_pdata -> m_data . size ( ) - rep_off ;




if ( pocessive )
{
if ( m_position != m_end )
{




switch ( this -> m_traits . syntax_type ( * m_position ) )
{
case regex_constants :: syntax_star :
case regex_constants :: syntax_plus :
case regex_constants :: syntax_question :
case regex_constants :: syntax_open_brace :
fail ( regex_constants :: error_badrepeat , m_position - m_base ) ;
return false ;
}
}
re_brace * pb = static_cast < re_brace * > ( this -> insert_state ( insert_point , syntax_element_startmark , sizeof ( re_brace
#1048
) ) ) ;
pb -> index = - 3 ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
jmp = static_cast < re_jump * > ( this -> insert_state ( insert_point + sizeof ( re_brace ) , syntax_element_jump , sizeof
#1051
( re_jump ) ) ) ;
this -> m_pdata -> m_data . align ( ) ;
jmp -> alt . i = this -> m_pdata -> m_data . size ( ) - this -> getoffset ( jmp ) ;
pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_endmark , sizeof ( re_brace ) ) ) ;
pb -> index = - 3 ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
}
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_repeat_range ( bool isbasic )
{
static const char * incomplete_message = "Missing } in quantified repetition." ;



std :: size_t min , max ;
int v ;

while ( ( m_position != m_end ) && this -> m_traits . isctype ( * m_position , this -> m_mask_space ) )
++ m_position ;
if ( this -> m_position == this -> m_end )
{
if ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) )
{
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , incomplete_message ) ;
return false ;
}

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_brace ) -- m_position ;
return parse_literal ( ) ;
}

v = this -> m_traits . toi ( m_position , m_end , 10 ) ;

if ( v < 0 )
{
if ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) )
{
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , incomplete_message ) ;
return false ;
}

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_brace ) -- m_position ;
return parse_literal ( ) ;
}
while ( ( m_position != m_end ) && this -> m_traits . isctype ( * m_position , this -> m_mask_space ) )
++ m_position ;
if ( this -> m_position == this -> m_end )
{
if ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) )
{
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , incomplete_message ) ;
return false ;
}

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_brace ) -- m_position ;
return parse_literal ( ) ;
}
min = v ;

if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_comma )
{

++ m_position ;

while ( ( m_position != m_end ) && this -> m_traits . isctype ( * m_position , this -> m_mask_space ) )
++ m_position ;
if ( this -> m_position == this -> m_end )
{
if ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) )
{
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , incomplete_message ) ;
return false ;
}

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_brace ) -- m_position ;
return parse_literal ( ) ;
}

v = this -> m_traits . toi ( m_position , m_end , 10 ) ;
max = ( v >= 0 ) ? ( std :: size_t ) v : ( std :: numeric_limits < std :: size_t > :: max ) ( ) ;
}
else
{

max = min ;
}

while ( ( m_position != m_end ) && this -> m_traits . isctype ( * m_position , this -> m_mask_space ) )
++ m_position ;

if ( this -> m_position == this -> m_end )
{
if ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_perl_ex ) )
{
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , incomplete_message ) ;
return false ;
}

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_brace ) -- m_position ;
return parse_literal ( ) ;
}
if ( isbasic )
{
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_escape )
{
++ m_position ;
if ( this -> m_position == this -> m_end )
{
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , incomplete_message ) ;
return false ;
}
}
else
{
fail ( regex_constants :: error_brace , this -> m_position - this -> m_base , incomplete_message ) ;
return false ;
}
}
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_close_brace )
++ m_position ;
else
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_brace ) -- m_position ;
return parse_literal ( ) ;
}



if ( min > max )
{

m_position -= 2 ;
while ( this -> m_traits . isctype ( * m_position , this -> m_word_mask ) ) -- m_position ;
++ m_position ;
fail ( regex_constants :: error_badbrace , m_position - m_base ) ;
return false ;
}
return parse_repeat ( min , max ) ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_alt ( )
{




if (
( ( this -> m_last_state == 0 ) || ( this -> m_last_state -> type == syntax_element_startmark ) )
&&
! (
( ( this -> flags ( ) & regbase :: main_option_type ) == regbase :: perl_syntax_group )
&&
( ( this -> flags ( ) & regbase :: no_empty_expressions ) == 0 )
)
)
{
fail ( regex_constants :: error_empty , this -> m_position - this -> m_base , "A regular expression can start with the alternation operator |."
#1218
) ;
return false ;
}



if ( m_max_mark < m_mark_count )
m_max_mark = m_mark_count ;
if ( m_mark_reset >= 0 )
m_mark_count = m_mark_reset ;

++ m_position ;



re_syntax_base * pj = this -> append_state ( re_detail :: syntax_element_jump , sizeof ( re_jump ) ) ;
std :: ptrdiff_t jump_offset = this -> getoffset ( pj ) ;



re_alt * palt = static_cast < re_alt * > ( this -> insert_state ( this -> m_alt_insert_point , syntax_element_alt , re_alt_size
#1238
) ) ;
jump_offset += re_alt_size ;
this -> m_pdata -> m_data . align ( ) ;
palt -> alt . i = this -> m_pdata -> m_data . size ( ) - this -> getoffset ( palt ) ;




this -> m_alt_insert_point = this -> m_pdata -> m_data . size ( ) ;




if ( m_has_case_change )
{
static_cast < re_case * > (
this -> append_state ( syntax_element_toggle_case , sizeof ( re_case ) )
) -> icase = this -> m_icase ;
}
#1263
m_alt_jumps . push_back ( jump_offset ) ;
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_set ( )
{
static const char * incomplete_message = "Character set declaration starting with [ terminated prematurely - either no ] was found or the set had no content."
#1270
;
++ m_position ;
if ( m_position == m_end )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
basic_char_set < charT , traits > char_set ;

const charT * base = m_position ;
const charT * item_base = m_position ;

while ( m_position != m_end )
{
switch ( this -> m_traits . syntax_type ( * m_position ) )
{
case regex_constants :: syntax_caret :
if ( m_position == base )
{
char_set . negate ( ) ;
++ m_position ;
item_base = m_position ;
}
else
parse_set_literal ( char_set ) ;
break ;
case regex_constants :: syntax_close_set :
if ( m_position == item_base )
{
parse_set_literal ( char_set ) ;
break ;
}
else
{
++ m_position ;
if ( 0 == this -> append_set ( char_set ) )
{
fail ( regex_constants :: error_ctype , m_position - m_base ) ;
return false ;
}
}
return true ;
case regex_constants :: syntax_open_set :
if ( parse_inner_set ( char_set ) )
break ;
return true ;
case regex_constants :: syntax_escape :
{




++ m_position ;
if ( this -> m_traits . escape_syntax_type ( * m_position )
== regex_constants :: escape_type_class )
{
char_class_type m = this -> m_traits . lookup_classname ( m_position , m_position + 1 ) ;
if ( m != 0 )
{
char_set . add_class ( m ) ;
++ m_position ;
break ;
}
}
else if ( this -> m_traits . escape_syntax_type ( * m_position )
== regex_constants :: escape_type_not_class )
{

char_class_type m = this -> m_traits . lookup_classname ( m_position , m_position + 1 ) ;
if ( m != 0 )
{
char_set . add_negated_class ( m ) ;
++ m_position ;
break ;
}
}

-- m_position ;
parse_set_literal ( char_set ) ;
break ;
}
default :
parse_set_literal ( char_set ) ;
break ;
}
}
return m_position != m_end ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_inner_set ( basic_char_set < charT , traits > & char_set )
{
static const char * incomplete_message = "Character class declaration starting with [ terminated prematurely - either no ] was found or the set had no content."
#1362
;





if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
switch ( this -> m_traits . syntax_type ( * m_position ) )
{
case regex_constants :: syntax_dot :



-- m_position ;
parse_set_literal ( char_set ) ;
return true ;
case regex_constants :: syntax_colon :
{

if ( ( this -> flags ( ) & ( regbase :: main_option_type | regbase :: no_char_classes ) )
== ( regbase :: basic_syntax_group | regbase :: no_char_classes ) )
{
-- m_position ;
parse_set_literal ( char_set ) ;
return true ;
}

if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
const charT * name_first = m_position ;

if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
while ( ( m_position != m_end )
&& ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_colon ) )
++ m_position ;
const charT * name_last = m_position ;
if ( m_end == m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
if ( ( m_end == ++ m_position )
|| ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_set ) )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}



bool negated = false ;
if ( this -> m_traits . syntax_type ( * name_first ) == regex_constants :: syntax_caret )
{
++ name_first ;
negated = true ;
}
typedef typename traits :: char_class_type m_type ;
m_type m = this -> m_traits . lookup_classname ( name_first , name_last ) ;
if ( m == 0 )
{
if ( char_set . empty ( ) && ( name_last - name_first == 1 ) )
{

++ m_position ;
if ( ( m_position != m_end )
&& ( this -> m_traits . syntax_type ( * m_position )
== regex_constants :: syntax_close_set ) )
{
if ( this -> m_traits . escape_syntax_type ( * name_first )
== regex_constants :: escape_type_left_word )
{
++ m_position ;
this -> append_state ( syntax_element_word_start ) ;
return false ;
}
if ( this -> m_traits . escape_syntax_type ( * name_first )
== regex_constants :: escape_type_right_word )
{
++ m_position ;
this -> append_state ( syntax_element_word_end ) ;
return false ;
}
}
}
fail ( regex_constants :: error_ctype , name_first - m_base ) ;
return false ;
}
if ( negated == false )
char_set . add_class ( m ) ;
else
char_set . add_negated_class ( m ) ;
++ m_position ;
break ;
}
case regex_constants :: syntax_equal :
{

if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
const charT * name_first = m_position ;

if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
while ( ( m_position != m_end )
&& ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_equal ) )
++ m_position ;
const charT * name_last = m_position ;
if ( m_end == m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
if ( ( m_end == ++ m_position )
|| ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_set ) )
{
fail ( regex_constants :: error_brack , m_position - m_base , incomplete_message ) ;
return false ;
}
string_type m = this -> m_traits . lookup_collatename ( name_first , name_last ) ;
if ( ( 0 == m . size ( ) ) || ( m . size ( ) > 2 ) )
{
fail ( regex_constants :: error_collate , name_first - m_base ) ;
return false ;
}
digraph < charT > d ;
d . first = m [ 0 ] ;
if ( m . size ( ) > 1 )
d . second = m [ 1 ] ;
else
d . second = 0 ;
char_set . add_equivalent ( d ) ;
++ m_position ;
break ;
}
default :
-- m_position ;
parse_set_literal ( char_set ) ;
break ;
}
return true ;
}

template < class charT , class traits >
void basic_regex_parser < charT , traits > :: parse_set_literal ( basic_char_set < charT , traits > & char_set )
{
digraph < charT > start_range ( get_next_set_literal ( char_set ) ) ;
if ( m_end == m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base ) ;
return ;
}
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_dash )
{

if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base ) ;
return ;
}
if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_set )
{
digraph < charT > end_range = get_next_set_literal ( char_set ) ;
char_set . add_range ( start_range , end_range ) ;
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_dash )
{
if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_brack , m_position - m_base ) ;
return ;
}
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_close_set )
{

-- m_position ;
return ;
}
fail ( regex_constants :: error_range , m_position - m_base ) ;
return ;
}
return ;
}
-- m_position ;
}
char_set . add_single ( start_range ) ;
}

template < class charT , class traits >
digraph < charT > basic_regex_parser < charT , traits > :: get_next_set_literal ( basic_char_set < charT , traits > & char_set
#1566
)
{
digraph < charT > result ;
switch ( this -> m_traits . syntax_type ( * m_position ) )
{
case regex_constants :: syntax_dash :
if ( ! char_set . empty ( ) )
{

if ( ( ++ m_position == m_end ) || ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_set
#1575
) )
{
fail ( regex_constants :: error_range , m_position - m_base ) ;
return result ;
}
-- m_position ;
}
result . first = * m_position ++ ;
return result ;
case regex_constants :: syntax_escape :

if ( this -> flags ( ) & regex_constants :: no_escape_in_lists )
{
result = * m_position ++ ;
break ;
}
++ m_position ;
result = unescape_character ( ) ;
break ;
case regex_constants :: syntax_open_set :
{
if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_collate , m_position - m_base ) ;
return result ;
}
if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_dot )
{
-- m_position ;
result . first = * m_position ;
++ m_position ;
return result ;
}
if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_collate , m_position - m_base ) ;
return result ;
}
const charT * name_first = m_position ;

if ( m_end == ++ m_position )
{
fail ( regex_constants :: error_collate , name_first - m_base ) ;
return result ;
}
while ( ( m_position != m_end )
&& ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_dot ) )
++ m_position ;
const charT * name_last = m_position ;
if ( m_end == m_position )
{
fail ( regex_constants :: error_collate , name_first - m_base ) ;
return result ;
}
if ( ( m_end == ++ m_position )
|| ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_set ) )
{
fail ( regex_constants :: error_collate , name_first - m_base ) ;
return result ;
}
++ m_position ;
string_type s = this -> m_traits . lookup_collatename ( name_first , name_last ) ;
if ( s . empty ( ) || ( s . size ( ) > 2 ) )
{
fail ( regex_constants :: error_collate , name_first - m_base ) ;
return result ;
}
result . first = s [ 0 ] ;
if ( s . size ( ) > 1 )
result . second = s [ 1 ] ;
else
result . second = 0 ;
return result ;
}
default :
result = * m_position ++ ;
}
return result ;
}




template < class charT >
bool valid_value ( charT , int v , const mpl :: true_ & )
{
return ( v >> ( sizeof ( charT ) * 8 ) ) == 0 ;
}
template < class charT >
bool valid_value ( charT , int , const mpl :: false_ & )
{
return true ;
}
template < class charT >
bool valid_value ( charT c , int v )
{
return valid_value ( c , v , mpl :: bool_ < ( sizeof ( charT ) < sizeof ( int ) ) > ( ) ) ;
}

template < class charT , class traits >
charT basic_regex_parser < charT , traits > :: unescape_character ( )
{




charT result ( 0 ) ;
if ( m_position == m_end )
{
fail ( regex_constants :: error_escape , m_position - m_base , "Escape sequence terminated prematurely." ) ;
return false ;
}
switch ( this -> m_traits . escape_syntax_type ( * m_position ) )
{
case regex_constants :: escape_type_control_a :
result = charT ( '\a' ) ;
break ;
case regex_constants :: escape_type_e :
result = charT ( 27 ) ;
break ;
case regex_constants :: escape_type_control_f :
result = charT ( '\f' ) ;
break ;
case regex_constants :: escape_type_control_n :
result = charT ( '\n' ) ;
break ;
case regex_constants :: escape_type_control_r :
result = charT ( '\r' ) ;
break ;
case regex_constants :: escape_type_control_t :
result = charT ( '\t' ) ;
break ;
case regex_constants :: escape_type_control_v :
result = charT ( '\v' ) ;
break ;
case regex_constants :: escape_type_word_assert :
result = charT ( '\b' ) ;
break ;
case regex_constants :: escape_type_ascii_control :
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base , "ASCII escape sequence terminated prematurely." ) ;
return result ;
}
result = static_cast < charT > ( * m_position % 32 ) ;
break ;
case regex_constants :: escape_type_hex :
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base , "Hexadecimal escape sequence terminated prematurely." ) ;
#1732

return result ;
}

if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_open_brace )
{
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base , "Missing } in hexadecimal escape sequence." ) ;
return result ;
}
int i = this -> m_traits . toi ( m_position , m_end , 16 ) ;
if ( ( m_position == m_end )
|| ( i < 0 )
|| ( ( std :: numeric_limits < charT > :: is_specialized ) && ( i > ( int ) ( std :: numeric_limits < charT > :: max ) (
#1750
) ) )
|| ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_brace ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_badbrace , m_position - m_base , "Hexadecimal escape sequence was invalid." ) ;
return result ;
}
++ m_position ;
result = charT ( i ) ;
}
else
{
std :: ptrdiff_t len = ( std :: min ) ( static_cast < std :: ptrdiff_t > ( 2 ) , static_cast < std :: ptrdiff_t > ( m_end
#1764
- m_position ) ) ;
int i = this -> m_traits . toi ( m_position , m_position + len , 16 ) ;
if ( ( i < 0 )
|| ! valid_value ( charT ( 0 ) , i ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base , "Escape sequence did not encode a valid character." ) ;
return result ;
}
result = charT ( i ) ;
}
return result ;
case regex_constants :: syntax_digit :
{


std :: ptrdiff_t len = ( std :: min ) ( :: boost :: re_detail :: distance ( m_position , m_end ) , static_cast < std :: ptrdiff_t
#1782
> ( 4 ) ) ;
const charT * bp = m_position ;
int val = this -> m_traits . toi ( bp , bp + 1 , 8 ) ;
if ( val != 0 )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;

fail ( regex_constants :: error_escape , m_position - m_base , "Invalid octal escape sequence." ) ;
return result ;
}
val = this -> m_traits . toi ( m_position , m_position + len , 8 ) ;
if ( val < 0 )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base , "Octal escape sequence is invalid." ) ;
return result ;
}
return static_cast < charT > ( val ) ;
}
case regex_constants :: escape_type_named_char :
{
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base ) ;
return false ;
}

if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_open_brace )
{
const charT * base = m_position ;

while ( ( m_position != m_end ) && ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_brace
#1821
) )
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base ) ;
return false ;
}
string_type s = this -> m_traits . lookup_collatename ( ++ base , m_position ++ ) ;
if ( s . empty ( ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_collate , m_position - m_base ) ;
return false ;
}
if ( s . size ( ) == 1 )
{
return s [ 0 ] ;
}
}


-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base ) ;
return false ;
}
default :
result = * m_position ;
break ;
}
++ m_position ;
return result ;



}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_backref ( )
{
( ( void ) 0 ) ;
const charT * pc = m_position ;
int i = this -> m_traits . toi ( pc , pc + 1 , 10 ) ;
if ( ( i == 0 ) || ( ( ( this -> flags ( ) & regbase :: main_option_type ) == regbase :: perl_syntax_group ) && ( this ->
#1869
flags ( ) & regbase :: no_bk_refs ) ) )
{

charT c = unescape_character ( ) ;
this -> append_literal ( c ) ;
}
else if ( ( i > 0 ) && ( this -> m_backrefs & ( 1u << ( i - 1 ) ) ) )
{
m_position = pc ;
re_brace * pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_backref , sizeof ( re_brace ) ) ) ;
pb -> index = i ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
}
else
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_backref , m_position - m_base ) ;
return false ;
}
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_QE ( )
{
#1903
++ m_position ;
const charT * start = m_position ;
const charT * end ;
do
{
while ( ( m_position != m_end )
&& ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) )
++ m_position ;
if ( m_position == m_end )
{

end = m_position ;
break ;
}
if ( ++ m_position == m_end )
{
fail ( regex_constants :: error_escape , m_position - m_base , "Unterminated \\Q...\\E sequence." ) ;
return false ;
}

if ( this -> m_traits . escape_syntax_type ( * m_position ) == regex_constants :: escape_type_E )
{
++ m_position ;
end = m_position - 2 ;
break ;
}

} while ( true ) ;



while ( start != end )
{
this -> append_literal ( * start ) ;
++ start ;
}
return true ;



}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: parse_perl_extension ( )
{
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}





if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_hash )
{
while ( ( m_position != m_end )
&& ( this -> m_traits . syntax_type ( * m_position ++ ) != regex_constants :: syntax_close_mark ) )
{ }
return true ;
}



int markid = 0 ;
std :: ptrdiff_t jump_offset = 0 ;
re_brace * pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_startmark , sizeof ( re_brace ) ) ) ;
#1973

pb -> icase = this -> flags ( ) & regbase :: icase ;
std :: ptrdiff_t last_paren_start = this -> getoffset ( pb ) ;

std :: ptrdiff_t last_alt_point = m_alt_insert_point ;
this -> m_pdata -> m_data . align ( ) ;
m_alt_insert_point = this -> m_pdata -> m_data . size ( ) ;
std :: ptrdiff_t expected_alt_point = m_alt_insert_point ;
bool restore_flags = true ;
regex_constants :: syntax_option_type old_flags = this -> flags ( ) ;
bool old_case_change = m_has_case_change ;
m_has_case_change = false ;
charT name_delim ;
int mark_reset = m_mark_reset ;
int max_mark = m_max_mark ;
m_mark_reset = - 1 ;
m_max_mark = m_mark_count ;
int v ;



switch ( this -> m_traits . syntax_type ( * m_position ) )
{
case regex_constants :: syntax_or :
m_mark_reset = m_mark_count ;
( ( void ) 0 ) ;
case regex_constants :: syntax_colon :



pb -> index = markid = 0 ;
++ m_position ;
break ;
case regex_constants :: syntax_digit :
{



v = this -> m_traits . toi ( m_position , m_end , 10 ) ;
if ( ( v < 0 ) || ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base , "The recursive sub-expression refers to an invalid marking group, or is unterminated."
#2017
) ;
return false ;
}
insert_recursion :
pb -> index = markid = 0 ;
re_recurse * pr = static_cast < re_recurse * > ( this -> append_state ( syntax_element_recurse , sizeof ( re_recurse ) )
#2022
) ;
pr -> alt . i = v ;
pr -> state_id = 0 ;
static_cast < re_case * > (
this -> append_state ( syntax_element_toggle_case , sizeof ( re_case ) )
) -> icase = this -> flags ( ) & regbase :: icase ;
break ;
}
case regex_constants :: syntax_plus :



++ m_position ;
v = this -> m_traits . toi ( m_position , m_end , 10 ) ;
if ( ( v <= 0 ) || ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base , "An invalid or unterminated recursive sub-expression."
#2041
) ;
return false ;
}
v += m_mark_count ;
goto insert_recursion ;
case regex_constants :: syntax_dash :



++ m_position ;
v = this -> m_traits . toi ( m_position , m_end , 10 ) ;
if ( v <= 0 )
{
-- m_position ;

goto option_group_jump ;
}
v = m_mark_count + 1 - v ;
if ( v <= 0 )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base , "An invalid or unterminated recursive sub-expression."
#2064
) ;
return false ;
}
goto insert_recursion ;
case regex_constants :: syntax_equal :
pb -> index = markid = - 1 ;
++ m_position ;
jump_offset = this -> getoffset ( this -> append_state ( syntax_element_jump , sizeof ( re_jump ) ) ) ;
this -> m_pdata -> m_data . align ( ) ;
m_alt_insert_point = this -> m_pdata -> m_data . size ( ) ;
break ;
case regex_constants :: syntax_not :
pb -> index = markid = - 2 ;
++ m_position ;
jump_offset = this -> getoffset ( this -> append_state ( syntax_element_jump , sizeof ( re_jump ) ) ) ;
this -> m_pdata -> m_data . align ( ) ;
m_alt_insert_point = this -> m_pdata -> m_data . size ( ) ;
break ;
case regex_constants :: escape_type_left_word :
{

if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
regex_constants :: syntax_type t = this -> m_traits . syntax_type ( * m_position ) ;
if ( t == regex_constants :: syntax_not )
pb -> index = markid = - 2 ;
else if ( t == regex_constants :: syntax_equal )
pb -> index = markid = - 1 ;
else
{

name_delim = '>' ;
-- m_position ;
goto named_capture_jump ;
}
++ m_position ;
jump_offset = this -> getoffset ( this -> append_state ( syntax_element_jump , sizeof ( re_jump ) ) ) ;
this -> append_state ( syntax_element_backstep , sizeof ( re_brace ) ) ;
this -> m_pdata -> m_data . align ( ) ;
m_alt_insert_point = this -> m_pdata -> m_data . size ( ) ;
break ;
}
case regex_constants :: escape_type_right_word :



pb -> index = markid = - 3 ;
++ m_position ;
jump_offset = this -> getoffset ( this -> append_state ( syntax_element_jump , sizeof ( re_jump ) ) ) ;
this -> m_pdata -> m_data . align ( ) ;
m_alt_insert_point = this -> m_pdata -> m_data . size ( ) ;
break ;
case regex_constants :: syntax_open_mark :
{

pb -> index = markid = - 4 ;
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
v = this -> m_traits . toi ( m_position , m_end , 10 ) ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( * m_position == charT ( 'R' ) )
{
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( * m_position == charT ( '&' ) )
{
const charT * base = ++ m_position ;
while ( ( m_position != m_end ) && ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark
#2156
) )
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
v = - static_cast < int > ( hash_value_from_capture_name ( base , m_position ) ) ;
}
else
{
v = - this -> m_traits . toi ( m_position , m_end , 10 ) ;
}
re_brace * br = static_cast < re_brace * > ( this -> append_state ( syntax_element_assert_backref , sizeof ( re_brace ) )
#2172
) ;
br -> index = v < 0 ? ( v - 1 ) : 0 ;
if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
}
else if ( ( * m_position == charT ( '\'' ) ) || ( * m_position == charT ( '<' ) ) )
{
const charT * base = ++ m_position ;
while ( ( m_position != m_end ) && ( * m_position != charT ( '>' ) ) && ( * m_position != charT ( '\'' ) ) )
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
v = static_cast < int > ( hash_value_from_capture_name ( base , m_position ) ) ;
re_brace * br = static_cast < re_brace * > ( this -> append_state ( syntax_element_assert_backref , sizeof ( re_brace ) )
#2205
) ;
br -> index = v ;
if ( ( ( * m_position != charT ( '>' ) ) && ( * m_position != charT ( '\'' ) ) ) || ( ++ m_position == m_end ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base , "Unterminated named capture." ) ;
return false ;
}
if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
}
else if ( * m_position == charT ( 'D' ) )
{
const char * def = "DEFINE" ;
while ( * def && ( m_position != m_end ) && ( * m_position == charT ( * def ) ) )
++ m_position , ++ def ;
if ( ( m_position == m_end ) || * def )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
re_brace * br = static_cast < re_brace * > ( this -> append_state ( syntax_element_assert_backref , sizeof ( re_brace ) )
#2245
) ;
br -> index = 9999 ;
if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
}
else if ( v > 0 )
{
re_brace * br = static_cast < re_brace * > ( this -> append_state ( syntax_element_assert_backref , sizeof ( re_brace ) )
#2266
) ;
br -> index = v ;
if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
}
else
{

if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_question )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: escape_type_left_word )
{
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_equal )
&& ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_not ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
m_position -= 3 ;
}
else
{
if ( ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_equal )
&& ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_not ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
m_position -= 2 ;
}
}
break ;
}
case regex_constants :: syntax_close_mark :

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
case regex_constants :: escape_type_end_buffer :
{
name_delim = * m_position ;
named_capture_jump :
markid = 0 ;
if ( 0 == ( this -> flags ( ) & regbase :: nosubs ) )
{
markid = ++ m_mark_count ;

if ( this -> flags ( ) & regbase :: save_subexpression_location )
this -> m_pdata -> m_subs . push_back ( std :: pair < std :: size_t , std :: size_t > ( std :: distance ( m_base , m_position
#2357
) - 2 , 0 ) ) ;




}
pb -> index = markid ;
const charT * base = ++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
while ( ( m_position != m_end ) && ( * m_position != name_delim ) )
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
this -> m_pdata -> set_name ( base , m_position , markid ) ;
++ m_position ;
break ;
}
default :
if ( * m_position == charT ( 'R' ) )
{
++ m_position ;
v = 0 ;
if ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
goto insert_recursion ;
}
if ( * m_position == charT ( '&' ) )
{
++ m_position ;
const charT * base = m_position ;
while ( ( m_position != m_end ) && ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark
#2406
) )
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
v = static_cast < int > ( hash_value_from_capture_name ( base , m_position ) ) ;
goto insert_recursion ;
}
if ( * m_position == charT ( 'P' ) )
{
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
if ( * m_position == charT ( '>' ) )
{
++ m_position ;
const charT * base = m_position ;
while ( ( m_position != m_end ) && ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_close_mark
#2434
) )
++ m_position ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}
v = static_cast < int > ( hash_value_from_capture_name ( base , m_position ) ) ;
goto insert_recursion ;
}
}



option_group_jump :
regex_constants :: syntax_option_type opts = parse_options ( ) ;
if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}

m_has_case_change = ( ( opts & regbase :: icase ) != ( this -> flags ( ) & regbase :: icase ) ) ;
pb -> index = markid = 0 ;
if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_close_mark )
{

this -> flags ( opts ) ;
restore_flags = false ;
old_case_change |= m_has_case_change ;
}
else if ( this -> m_traits . syntax_type ( * m_position ) == regex_constants :: syntax_colon )
{

this -> flags ( opts ) ;
++ m_position ;
}
else
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base ) ;
return false ;
}


if ( m_has_case_change )
{
static_cast < re_case * > (
this -> append_state ( syntax_element_toggle_case , sizeof ( re_case ) )
) -> icase = opts & regbase :: icase ;
}

}




parse_all ( ) ;



if ( 0 == unwind_alts ( last_paren_start ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base , "Invalid alternation operators within (?...) block."
#2508
) ;
return false ;
}



if ( m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
this -> fail ( regex_constants :: error_paren , :: boost :: re_detail :: distance ( m_base , m_end ) ) ;
return false ;
}
( ( void ) 0 ) ;
++ m_position ;



if ( restore_flags )
{

if ( m_has_case_change )
{
static_cast < re_case * > (
this -> append_state ( syntax_element_toggle_case , sizeof ( re_case ) )
) -> icase = old_flags & regbase :: icase ;
}
this -> flags ( old_flags ) ;
}



if ( jump_offset )
{
this -> m_pdata -> m_data . align ( ) ;
re_jump * jmp = static_cast < re_jump * > ( this -> getaddress ( jump_offset ) ) ;
jmp -> alt . i = this -> m_pdata -> m_data . size ( ) - this -> getoffset ( jmp ) ;
if ( ( this -> m_last_state == jmp ) && ( markid != - 2 ) )
{




-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_perl_extension , m_position - m_base , "Invalid or empty zero width assertion." ) ;
return false ;
}
}




if ( markid == - 4 )
{
re_syntax_base * b = this -> getaddress ( expected_alt_point ) ;

if ( b -> type != syntax_element_alt )
{
re_alt * alt = static_cast < re_alt * > ( this -> insert_state ( expected_alt_point , syntax_element_alt , sizeof ( re_alt
#2568
) ) ) ;
alt -> alt . i = this -> m_pdata -> m_data . size ( ) - this -> getoffset ( alt ) ;
}
else if ( this -> getaddress ( static_cast < re_alt * > ( b ) -> alt . i , b ) -> type == syntax_element_alt )
{


-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_bad_pattern , m_position - m_base , "More than one alternation operator | was encountered inside a conditional expression."
#2577
) ;
return false ;
}
else
{

b = this -> getaddress ( b -> next . i , b ) ;
if ( ( b -> type == syntax_element_assert_backref ) && ( static_cast < re_brace * > ( b ) -> index == 9999 ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_bad_pattern , m_position - m_base , "Alternation operators are not allowed inside a DEFINE block."
#2589
) ;
return false ;
}
}

b = this -> getaddress ( expected_alt_point ) ;
b = this -> getaddress ( static_cast < re_alt * > ( b ) -> next . i , b ) ;
if ( ( b -> type != syntax_element_assert_backref )
&& ( b -> type != syntax_element_startmark ) )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_badrepeat , m_position - m_base , "A repetition operator cannot be applied to a zero-width assertion."
#2602
) ;
return false ;
}
}



pb = static_cast < re_brace * > ( this -> append_state ( syntax_element_endmark , sizeof ( re_brace ) ) ) ;
pb -> index = markid ;
pb -> icase = this -> flags ( ) & regbase :: icase ;
this -> m_paren_start = last_paren_start ;



this -> m_alt_insert_point = last_alt_point ;



m_has_case_change = old_case_change ;



if ( m_max_mark > m_mark_count )
{
m_mark_count = m_max_mark ;
}
m_mark_reset = mark_reset ;
m_max_mark = max_mark ;


if ( markid > 0 )
{

if ( this -> flags ( ) & regbase :: save_subexpression_location )
this -> m_pdata -> m_subs . at ( markid - 1 ) . second = std :: distance ( m_base , m_position ) - 1 ;
#2644
if ( ( markid > 0 ) && ( markid < ( int ) ( sizeof ( unsigned ) * 8 ) ) )
this -> m_backrefs |= 1u << ( markid - 1 ) ;
}
return true ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: add_emacs_code ( bool negate )
{



if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_escape ) -- m_position ;
fail ( regex_constants :: error_escape , m_position - m_base ) ;
return false ;
}
basic_char_set < charT , traits > char_set ;
if ( negate )
char_set . negate ( ) ;

static const charT s_punct [ 5 ] = { 'p' , 'u' , 'n' , 'c' , 't' , } ;

switch ( * m_position )
{
case 's' :
case ' ' :
char_set . add_class ( this -> m_mask_space ) ;
break ;
case 'w' :
char_set . add_class ( this -> m_word_mask ) ;
break ;
case '_' :
char_set . add_single ( digraph < charT > ( charT ( '$' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '&' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '*' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '+' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '-' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '_' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '<' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '>' ) ) ) ;
break ;
case '.' :
char_set . add_class ( this -> m_traits . lookup_classname ( s_punct , s_punct + 5 ) ) ;
break ;
case '(' :
char_set . add_single ( digraph < charT > ( charT ( '(' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '[' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '{' ) ) ) ;
break ;
case ')' :
char_set . add_single ( digraph < charT > ( charT ( ')' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( ']' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '}' ) ) ) ;
break ;
case '"' :
char_set . add_single ( digraph < charT > ( charT ( '"' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '\'' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '`' ) ) ) ;
break ;
case '\'' :
char_set . add_single ( digraph < charT > ( charT ( '\'' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( ',' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '#' ) ) ) ;
break ;
case '<' :
char_set . add_single ( digraph < charT > ( charT ( ';' ) ) ) ;
break ;
case '>' :
char_set . add_single ( digraph < charT > ( charT ( '\n' ) ) ) ;
char_set . add_single ( digraph < charT > ( charT ( '\f' ) ) ) ;
break ;
default :
fail ( regex_constants :: error_ctype , m_position - m_base ) ;
return false ;
}
if ( 0 == this -> append_set ( char_set ) )
{
fail ( regex_constants :: error_ctype , m_position - m_base ) ;
return false ;
}
++ m_position ;
return true ;
}

template < class charT , class traits >
regex_constants :: syntax_option_type basic_regex_parser < charT , traits > :: parse_options ( )
{

regex_constants :: syntax_option_type f = this -> flags ( ) ;
bool breakout = false ;
do
{
switch ( * m_position )
{
case 's' :
f |= regex_constants :: mod_s ;
f &= ~ regex_constants :: no_mod_s ;
break ;
case 'm' :
f &= ~ regex_constants :: no_mod_m ;
break ;
case 'i' :
f |= regex_constants :: icase ;
break ;
case 'x' :
f |= regex_constants :: mod_x ;
break ;
default :
breakout = true ;
continue ;
}
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_paren , m_position - m_base ) ;
return false ;
}
}
while ( ! breakout ) ;

breakout = false ;

if ( * m_position == static_cast < charT > ( '-' ) )
{
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_paren , m_position - m_base ) ;
return false ;
}
do
{
switch ( * m_position )
{
case 's' :
f &= ~ regex_constants :: mod_s ;
f |= regex_constants :: no_mod_s ;
break ;
case 'm' :
f |= regex_constants :: no_mod_m ;
break ;
case 'i' :
f &= ~ regex_constants :: icase ;
break ;
case 'x' :
f &= ~ regex_constants :: mod_x ;
break ;
default :
breakout = true ;
continue ;
}
if ( ++ m_position == m_end )
{

-- m_position ;
while ( this -> m_traits . syntax_type ( * m_position ) != regex_constants :: syntax_open_mark ) -- m_position ;
fail ( regex_constants :: error_paren , m_position - m_base ) ;
return false ;
}
}
while ( ! breakout ) ;
}
return f ;
}

template < class charT , class traits >
bool basic_regex_parser < charT , traits > :: unwind_alts ( std :: ptrdiff_t last_paren_start )
{




if ( ( this -> m_alt_insert_point == static_cast < std :: ptrdiff_t > ( this -> m_pdata -> m_data . size ( ) ) )
&& m_alt_jumps . size ( ) && ( m_alt_jumps . back ( ) > last_paren_start )
&&
! (
( ( this -> flags ( ) & regbase :: main_option_type ) == regbase :: perl_syntax_group )
&&
( ( this -> flags ( ) & regbase :: no_empty_expressions ) == 0 )
)
)
{
fail ( regex_constants :: error_empty , this -> m_position - this -> m_base , "Can't terminate a sub-expression with an alternation operator |."
#2834
) ;
return false ;
}



while ( m_alt_jumps . size ( ) && ( m_alt_jumps . back ( ) > last_paren_start ) )
{




std :: ptrdiff_t jump_offset = m_alt_jumps . back ( ) ;
m_alt_jumps . pop_back ( ) ;
this -> m_pdata -> m_data . align ( ) ;
re_jump * jmp = static_cast < re_jump * > ( this -> getaddress ( jump_offset ) ) ;
( ( void ) 0 ) ;
jmp -> alt . i = this -> m_pdata -> m_data . size ( ) - jump_offset ;
}
return true ;
}





}
}
#1 "./boost/regex/v4/sub_match.hpp"
#33
namespace boost {

template < class BidiIterator >
struct sub_match : public std :: pair < BidiIterator , BidiIterator >
{
typedef typename re_detail :: regex_iterator_traits < BidiIterator > :: value_type value_type ;



typedef typename re_detail :: regex_iterator_traits < BidiIterator > :: difference_type difference_type ;

typedef BidiIterator iterator_type ;
typedef BidiIterator iterator ;
typedef BidiIterator const_iterator ;

bool matched ;

sub_match ( ) : std :: pair < BidiIterator , BidiIterator > ( ) , matched ( false ) { }
sub_match ( BidiIterator i ) : std :: pair < BidiIterator , BidiIterator > ( i , i ) , matched ( false ) { }




template < class T , class A >
operator std :: basic_string < value_type , T , A > ( ) const
{
return matched ? std :: basic_string < value_type , T , A > ( this -> first , this -> second ) : std :: basic_string < value_type
#59
, T , A > ( ) ;
}
#67
difference_type length ( ) const
{
difference_type n = matched ? :: boost :: re_detail :: distance ( ( BidiIterator ) this -> first , ( BidiIterator ) this
#69
-> second ) : 0 ;
return n ;
}
std :: basic_string < value_type > str ( ) const
{
std :: basic_string < value_type > result ;
if ( matched )
{
std :: size_t len = :: boost :: re_detail :: distance ( ( BidiIterator ) this -> first , ( BidiIterator ) this -> second
#77
) ;
result . reserve ( len ) ;
BidiIterator i = this -> first ;
while ( i != this -> second )
{
result . append ( 1 , * i ) ;
++ i ;
}
}
return result ;
}
int compare ( const sub_match & s ) const
{
if ( matched != s . matched )
return static_cast < int > ( matched ) - static_cast < int > ( s . matched ) ;
return str ( ) . compare ( s . str ( ) ) ;
}
int compare ( const std :: basic_string < value_type > & s ) const
{
return str ( ) . compare ( s ) ;
}
int compare ( const value_type * p ) const
{
return str ( ) . compare ( p ) ;
}

bool operator == ( const sub_match & that ) const
{ return compare ( that ) == 0 ; }
bool operator != ( const sub_match & that ) const
{ return compare ( that ) != 0 ; }
bool operator < ( const sub_match & that ) const
{ return compare ( that ) < 0 ; }
bool operator > ( const sub_match & that ) const
{ return compare ( that ) > 0 ; }
bool operator <= ( const sub_match & that ) const
{ return compare ( that ) <= 0 ; }
bool operator >= ( const sub_match & that ) const
{ return compare ( that ) >= 0 ; }
#140
sub_match ( const sub_match & that , bool



= true
)
: std :: pair < BidiIterator , BidiIterator > ( that ) ,
matched ( that . matched )
{





}
sub_match & operator = ( const sub_match & that )
{
this -> first = that . first ;
this -> second = that . second ;
matched = that . matched ;




return * this ;
}
#183
} ;

typedef sub_match < const char * > csub_match ;
typedef sub_match < std :: string :: const_iterator > ssub_match ;

typedef sub_match < const wchar_t * > wcsub_match ;
typedef sub_match < std :: wstring :: const_iterator > wssub_match ;



template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator == ( const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator
#194
> :: value_type , traits , Allocator > & s ,
const sub_match < RandomAccessIterator > & m )
{ return s . compare ( m . str ( ) ) == 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator != ( const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator
#198
> :: value_type , traits , Allocator > & s ,
const sub_match < RandomAccessIterator > & m )
{ return s . compare ( m . str ( ) ) != 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator < ( const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator >
#202
:: value_type , traits , Allocator > & s ,
const sub_match < RandomAccessIterator > & m )
{ return s . compare ( m . str ( ) ) < 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator <= ( const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator
#206
> :: value_type , traits , Allocator > & s ,
const sub_match < RandomAccessIterator > & m )
{ return s . compare ( m . str ( ) ) <= 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator >= ( const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator
#210
> :: value_type , traits , Allocator > & s ,
const sub_match < RandomAccessIterator > & m )
{ return s . compare ( m . str ( ) ) >= 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator > ( const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator >
#214
:: value_type , traits , Allocator > & s ,
const sub_match < RandomAccessIterator > & m )
{ return s . compare ( m . str ( ) ) > 0 ; }

template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator == ( const sub_match < RandomAccessIterator > & m ,
const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits ,
#220
Allocator > & s )
{ return m . str ( ) . compare ( s ) == 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator != ( const sub_match < RandomAccessIterator > & m ,
const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits ,
#224
Allocator > & s )
{ return m . str ( ) . compare ( s ) != 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator < ( const sub_match < RandomAccessIterator > & m ,
const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits ,
#228
Allocator > & s )
{ return m . str ( ) . compare ( s ) < 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator > ( const sub_match < RandomAccessIterator > & m ,
const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits ,
#232
Allocator > & s )
{ return m . str ( ) . compare ( s ) > 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator <= ( const sub_match < RandomAccessIterator > & m ,
const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits ,
#236
Allocator > & s )
{ return m . str ( ) . compare ( s ) <= 0 ; }
template < class RandomAccessIterator , class traits , class Allocator >
inline bool operator >= ( const sub_match < RandomAccessIterator > & m ,
const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits ,
#240
Allocator > & s )
{ return m . str ( ) . compare ( s ) >= 0 ; }

template < class RandomAccessIterator >
inline bool operator == ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s )
{ return m . str ( ) . compare ( s ) == 0 ; }
template < class RandomAccessIterator >
inline bool operator != ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s )
{ return m . str ( ) . compare ( s ) != 0 ; }
template < class RandomAccessIterator >
inline bool operator > ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s )
{ return m . str ( ) . compare ( s ) > 0 ; }
template < class RandomAccessIterator >
inline bool operator < ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s )
{ return m . str ( ) . compare ( s ) < 0 ; }
template < class RandomAccessIterator >
inline bool operator >= ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s )
{ return m . str ( ) . compare ( s ) >= 0 ; }
template < class RandomAccessIterator >
inline bool operator <= ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s )
{ return m . str ( ) . compare ( s ) <= 0 ; }

template < class RandomAccessIterator >
inline bool operator == ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s ,
#269

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( s ) == 0 ; }
template < class RandomAccessIterator >
inline bool operator != ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s ,
#273

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( s ) != 0 ; }
template < class RandomAccessIterator >
inline bool operator < ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s ,
const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( s ) > 0 ; }
template < class RandomAccessIterator >
inline bool operator > ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s ,
const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( s ) < 0 ; }
template < class RandomAccessIterator >
inline bool operator <= ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s ,
#285

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( s ) >= 0 ; }
template < class RandomAccessIterator >
inline bool operator >= ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s ,
#289

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( s ) <= 0 ; }


template < class RandomAccessIterator >
inline bool operator == ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) == 0 ; }
template < class RandomAccessIterator >
inline bool operator != ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) != 0 ; }
template < class RandomAccessIterator >
inline bool operator > ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) > 0 ; }
template < class RandomAccessIterator >
inline bool operator < ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) < 0 ; }
template < class RandomAccessIterator >
inline bool operator >= ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) >= 0 ; }
template < class RandomAccessIterator >
inline bool operator <= ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) <= 0 ; }

template < class RandomAccessIterator >
inline bool operator == ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s ,
#320

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) == 0 ; }
template < class RandomAccessIterator >
inline bool operator != ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s ,
#324

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) != 0 ; }
template < class RandomAccessIterator >
inline bool operator < ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s ,
const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) > 0 ; }
template < class RandomAccessIterator >
inline bool operator > ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s ,
const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) < 0 ; }
template < class RandomAccessIterator >
inline bool operator <= ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s ,
#336

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) >= 0 ; }
template < class RandomAccessIterator >
inline bool operator >= ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s ,
#340

const sub_match < RandomAccessIterator > & m )
{ return m . str ( ) . compare ( 0 , m . length ( ) , & s , 1 ) <= 0 ; }


template < class RandomAccessIterator , class traits , class Allocator >
inline std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits
#346
, Allocator >
operator + ( const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type
#347
, traits , Allocator > & s ,
const sub_match < RandomAccessIterator > & m )
{
std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits , Allocator
#350
> result ;
result . reserve ( s . size ( ) + m . length ( ) + 1 ) ;
return result . append ( s ) . append ( m . first , m . second ) ;
}
template < class RandomAccessIterator , class traits , class Allocator >
inline std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits
#355
, Allocator >
operator + ( const sub_match < RandomAccessIterator > & m ,
const std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits ,
#357
Allocator > & s )
{
std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type , traits , Allocator
#359
> result ;
result . reserve ( s . size ( ) + m . length ( ) + 1 ) ;
return result . append ( m . first , m . second ) . append ( s ) ;
}

template < class RandomAccessIterator >
inline std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type >
operator + ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s ,
const sub_match < RandomAccessIterator > & m )
{
std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type > result ;
result . reserve ( std :: char_traits < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type
#370
> :: length ( s ) + m . length ( ) + 1 ) ;
return result . append ( s ) . append ( m . first , m . second ) ;
}
template < class RandomAccessIterator >
inline std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type >
operator + ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const * s )
{
std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type > result ;
result . reserve ( std :: char_traits < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type
#379
> :: length ( s ) + m . length ( ) + 1 ) ;
return result . append ( m . first , m . second ) . append ( s ) ;
}
#399
template < class RandomAccessIterator >
inline std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type >
operator + ( typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s ,
const sub_match < RandomAccessIterator > & m )
{
std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type > result ;
result . reserve ( m . length ( ) + 2 ) ;
return result . append ( 1 , s ) . append ( m . first , m . second ) ;
}
template < class RandomAccessIterator >
inline std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type >
operator + ( const sub_match < RandomAccessIterator > & m ,
typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type const & s )
{
std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type > result ;
result . reserve ( m . length ( ) + 2 ) ;
return result . append ( m . first , m . second ) . append ( 1 , s ) ;
}
template < class RandomAccessIterator >
inline std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type >
operator + ( const sub_match < RandomAccessIterator > & m1 ,
const sub_match < RandomAccessIterator > & m2 )
{
std :: basic_string < typename re_detail :: regex_iterator_traits < RandomAccessIterator > :: value_type > result ;
result . reserve ( m1 . length ( ) + m2 . length ( ) + 1 ) ;
return result . append ( m1 . first , m1 . second ) . append ( m2 . first , m2 . second ) ;
}

template < class charT , class traits , class RandomAccessIterator >
std :: basic_ostream < charT , traits > &
operator << ( std :: basic_ostream < charT , traits > & os ,
const sub_match < RandomAccessIterator > & s )
{
return ( os << s . str ( ) ) ;
}
#498
}
#1 "./boost/regex/v4/regex_format.hpp"
#1 "./boost/type_traits/is_pointer.hpp"
#1 "./boost/type_traits/is_member_pointer.hpp"
#1 "./boost/type_traits/is_member_function_pointer.hpp"
#1 "./boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
#25
namespace boost {
namespace type_traits {

template < typename T >
struct is_mem_fun_pointer_impl
{
static const bool value = false ;
} ;





template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ) > { static const bool value = true ; } ;

template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ... ) > { static const bool value = true ; } ;



template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ) const > { static const bool value = true ; } ;

template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ) volatile > { static const bool value = true ; } ;

template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ) const volatile > { static const bool value = true ; } ;


template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ... ) const > { static const bool value = true ; } ;

template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ... ) volatile > { static const bool value = true ; } ;

template < class R , class T >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 ... ) const volatile > { static const bool value = true ; }
#147
;


template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ) const volatile > { static const bool value = true ; }
#165
;


template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ... ) volatile > { static const bool value = true ; } ;
#172


template < class R , class T , class T0 , class T1 , class T2 , class T3 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 ... ) const volatile > { static const bool value = true
#175
; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ) volatile > { static const bool value = true ; }
#190
;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ) const volatile > { static const bool value = true
#193
; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ... ) const > { static const bool value = true ; }
#197
;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ... ) volatile > { static const bool value = true
#200
; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 ... ) const volatile > { static const bool value =
#203
true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ... ) > { static const bool value = true ; }
#210
;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ) const > { static const bool value = true ;
#215
} ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ) volatile > { static const bool value = true
#218
; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ) const volatile > { static const bool value
#221
= true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ... ) const > { static const bool value = true
#225
; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ... ) volatile > { static const bool value =
#228
true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 ... ) const volatile > { static const bool value
#231
= true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ) > { static const bool value = true ; }
#235
;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ... ) > { static const bool value = true
#238
; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ) const > { static const bool value = true
#243
; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ) volatile > { static const bool value =
#246
true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ) const volatile > { static const bool value
#249
= true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ... ) const > { static const bool value
#253
= true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ... ) volatile > { static const bool value
#256
= true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 ... ) const volatile > { static const bool
#259
value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) > { static const bool value = true
#263
; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ... ) > { static const bool value =
#266
true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const > { static const bool value
#271
= true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) volatile > { static const bool value
#274
= true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const volatile > { static const bool
#277
value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ... ) const > { static const bool value
#281
= true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ... ) volatile > { static const bool
#284
value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ... ) const volatile > { static const
#287
bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#290
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) > { static const bool value
#291
= true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#293
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ... ) > { static const bool value
#294
= true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#298
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const > { static const bool
#299
value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#301
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) volatile > { static const bool
#302
value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#304
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const volatile > { static const
#305
bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#308
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ... ) const > { static const bool
#309
value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#311
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ... ) volatile > { static const
#312
bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#314
T8 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ... ) const volatile > { static
#315
const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#318
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) > { static const bool value
#319
= true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#321
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ... ) > { static const bool
#322
value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#326
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const > { static const
#327
bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#329
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) volatile > { static const
#330
bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#332
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const volatile > { static
#333
const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#336
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ... ) const > { static const
#337
bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#339
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ... ) volatile > { static
#340
const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#342
T8 , class T9 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ... ) const volatile > {
#343
static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#346
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) > { static const
#347
bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#349
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ... ) > { static const
#350
bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#354
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const > { static
#355
const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#357
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) volatile > { static
#358
const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#360
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const volatile >
#361
{ static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#364
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ... ) const > { static
#365
const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#367
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ... ) volatile > {
#368
static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#370
T8 , class T9 , class T10 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ... ) const volatile
#371
> { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#374
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) > { static
#375
const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#377
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ... ) > { static
#378
const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#382
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const > { static
#383
const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#385
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) volatile >
#386
{ static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#388
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const volatile
#389
> { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#392
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ... ) const >
#393
{ static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#395
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ... ) volatile
#396
> { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#398
T8 , class T9 , class T10 , class T11 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ... ) const volatile
#399
> { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#402
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) > { static
#403
const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#405
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ... ) >
#406
{ static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#410
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const
#411
> { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#413
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) volatile
#414
> { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#416
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const
#417
volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#420
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ... ) const
#421
> { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#423
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ... ) volatile
#424
> { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#426
T8 , class T9 , class T10 , class T11 , class T12 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ... ) const
#427
volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#430
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 )
#431
> { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#433
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...
#434
) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#438
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 )
#439
const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#441
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 )
#442
volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#444
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 )
#445
const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#448
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...
#449
) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#451
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...
#452
) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#454
T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...
#455
) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#458
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#459
T14 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#461
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#462
T14 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#466
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#467
T14 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#469
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#470
T14 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#472
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#473
T14 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#476
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#477
T14 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#479
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#480
T14 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#482
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#483
T14 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#486
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#487
T14 , T15 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#489
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#490
T14 , T15 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#494
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#495
T14 , T15 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#497
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#498
T14 , T15 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#500
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#501
T14 , T15 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#504
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#505
T14 , T15 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#507
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#508
T14 , T15 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#510
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#511
T14 , T15 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#514
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#515
T14 , T15 , T16 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#517
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#518
T14 , T15 , T16 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#522
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#523
T14 , T15 , T16 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#525
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#526
T14 , T15 , T16 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#528
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#529
T14 , T15 , T16 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#532
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#533
T14 , T15 , T16 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#535
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#536
T14 , T15 , T16 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#538
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#539
T14 , T15 , T16 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#542
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#543
T14 , T15 , T16 , T17 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#545
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#546
T14 , T15 , T16 , T17 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#550
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#551
T14 , T15 , T16 , T17 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#553
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#554
T14 , T15 , T16 , T17 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#556
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#557
T14 , T15 , T16 , T17 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#560
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#561
T14 , T15 , T16 , T17 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#563
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#564
T14 , T15 , T16 , T17 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#566
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#567
T14 , T15 , T16 , T17 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#570
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#570
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#571
T14 , T15 , T16 , T17 , T18 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#573
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#573
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#574
T14 , T15 , T16 , T17 , T18 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#578
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#578
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#579
T14 , T15 , T16 , T17 , T18 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#581
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#581
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#582
T14 , T15 , T16 , T17 , T18 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#584
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#584
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#585
T14 , T15 , T16 , T17 , T18 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#588
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#588
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#589
T14 , T15 , T16 , T17 , T18 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#591
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#591
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#592
T14 , T15 , T16 , T17 , T18 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#594
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#594
>
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#595
T14 , T15 , T16 , T17 , T18 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#598
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#598
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#599
T14 , T15 , T16 , T17 , T18 , T19 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#601
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#601
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#602
T14 , T15 , T16 , T17 , T18 , T19 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#606
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#606
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#607
T14 , T15 , T16 , T17 , T18 , T19 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#609
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#609
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#610
T14 , T15 , T16 , T17 , T18 , T19 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#612
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#612
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#613
T14 , T15 , T16 , T17 , T18 , T19 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#616
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#616
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#617
T14 , T15 , T16 , T17 , T18 , T19 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#619
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#619
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#620
T14 , T15 , T16 , T17 , T18 , T19 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#622
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#622
, class T19 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#623
T14 , T15 , T16 , T17 , T18 , T19 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#626
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#626
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#627
T14 , T15 , T16 , T17 , T18 , T19 , T20 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#629
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#629
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#630
T14 , T15 , T16 , T17 , T18 , T19 , T20 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#634
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#634
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#635
T14 , T15 , T16 , T17 , T18 , T19 , T20 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#637
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#637
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#638
T14 , T15 , T16 , T17 , T18 , T19 , T20 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#640
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#640
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#641
T14 , T15 , T16 , T17 , T18 , T19 , T20 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#644
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#644
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#645
T14 , T15 , T16 , T17 , T18 , T19 , T20 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#647
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#647
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#648
T14 , T15 , T16 , T17 , T18 , T19 , T20 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#650
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#650
, class T19 , class T20 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#651
T14 , T15 , T16 , T17 , T18 , T19 , T20 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#654
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#654
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#655
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#657
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#657
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#658
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#662
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#662
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#663
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#665
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#665
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#666
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#668
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#668
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#669
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#672
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#672
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#673
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#675
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#675
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#676
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#678
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#678
, class T19 , class T20 , class T21 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#679
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#682
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#682
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#683
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#685
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#685
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#686
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#690
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#690
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#691
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#693
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#693
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#694
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#696
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#696
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#697
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#700
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#700
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#701
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#703
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#703
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#704
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#706
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#706
, class T19 , class T20 , class T21 , class T22 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#707
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#710
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#710
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#711
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#713
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#713
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#714
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#718
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#718
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#719
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#721
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#721
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#722
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#724
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#724
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#725
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#728
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#728
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#729
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#731
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#731
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#732
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#734
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#734
, class T19 , class T20 , class T21 , class T22 , class T23 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#735
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ... ) const volatile > { static const bool value = true ; } ;


template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#738
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#738
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#739
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ) > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#741
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#741
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#742
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ... ) > { static const bool value = true ; } ;



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#746
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#746
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#747
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#749
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#749
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#750
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#752
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#752
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#753
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ) const volatile > { static const bool value = true ; } ;
#753



template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#756
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#756
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#757
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ... ) const > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#759
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#759
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#760
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ... ) volatile > { static const bool value = true ; } ;

template < class R , class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class
#762
T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18
#762
, class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
struct is_mem_fun_pointer_impl < R ( T :: * ) ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ,
#763
T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ... ) const volatile > { static const bool value = true ;
#763
} ;
#776
}
}
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#38 "./boost/type_traits/is_member_function_pointer.hpp"
namespace boost {
#48
template < typename T > struct is_member_function_pointer : public :: boost :: integral_constant < bool , :: boost :: type_traits
#48
:: is_mem_fun_pointer_impl < typename remove_cv < T > :: type > :: value > { public : } ;
#132
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#41 "./boost/type_traits/is_member_pointer.hpp"
namespace boost {
#50
template < typename T > struct is_member_pointer : public :: boost :: integral_constant < bool , :: boost :: is_member_function_pointer
#50
< T > :: value > { public : } ;
template < typename T , typename U > struct is_member_pointer < U T :: * > : public :: boost :: integral_constant < bool
#51
, true > { public : } ;


template < typename T , typename U > struct is_member_pointer < U T :: * const > : public :: boost :: integral_constant <
#54
bool , true > { public : } ;
template < typename T , typename U > struct is_member_pointer < U T :: * volatile > : public :: boost :: integral_constant
#55
< bool , true > { public : } ;
template < typename T , typename U > struct is_member_pointer < U T :: * const volatile > : public :: boost :: integral_constant
#56
< bool , true > { public : } ;
#112
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/detail/bool_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#43 "./boost/type_traits/is_pointer.hpp"
namespace boost {





namespace detail {

template < typename T > struct is_pointer_helper
{
static const bool value = false ;
} ;
#63
template < typename T > struct is_pointer_helper < T * > { static const bool value = true ; } ;



template < typename T >
struct is_pointer_impl
{
#87
static const bool value = ( :: boost :: type_traits :: ice_and < :: boost :: detail :: is_pointer_helper < typename remove_cv
#87
< T > :: type > :: value , :: boost :: type_traits :: ice_not < :: boost :: is_member_pointer < T > :: value > :: value >
#87
:: value ) ;

} ;

}

template < typename T > struct is_pointer : public :: boost :: integral_constant < bool , :: boost :: detail :: is_pointer_impl
#93
< T > :: value > { public : } ;
#158
}
#1 "./boost/type_traits/detail/bool_trait_undef.hpp"
#1 "./boost/type_traits/remove_pointer.hpp"
#1 "./boost/type_traits/detail/type_trait_def.hpp"
#1 "./boost/type_traits/detail/template_arity_spec.hpp"
#28 "./boost/type_traits/remove_pointer.hpp"
namespace boost {
#76
template < typename T > struct remove_pointer { public : typedef T type ; } ;
template < typename T > struct remove_pointer < T * > { public : typedef T type ; } ;
template < typename T > struct remove_pointer < T * const > { public : typedef T type ; } ;
template < typename T > struct remove_pointer < T * volatile > { public : typedef T type ; } ;
template < typename T > struct remove_pointer < T * const volatile > { public : typedef T type ; } ;
#88
}
#1 "./boost/type_traits/detail/type_trait_undef.hpp"
#1 "./boost/mpl/if.hpp"
#1 "./boost/mpl/aux_/value_wknd.hpp"
#1 "./boost/mpl/aux_/config/integral.hpp"
#73 "./boost/mpl/aux_/value_wknd.hpp"
namespace boost { namespace mpl { namespace aux {

template < typename T > struct value_type_wknd
{
typedef typename T :: value_type type ;
} ;
#87
} } }
#25 "./boost/mpl/if.hpp"
namespace boost { namespace mpl {



template <
bool C
, typename T1
, typename T2
>
struct if_c
{
typedef T1 type ;
} ;

template <
typename T1
, typename T2
>
struct if_c < false , T1 , T2 >
{
typedef T2 type ;
} ;



template <
typename T1 = na
, typename T2 = na
, typename T3 = na
>
struct if_
{
private :

typedef if_c <



static_cast < bool > ( T1 :: value )

, T2
, T3
> almost_type_ ;

public :
typedef typename almost_type_ :: type type ;


} ;
#131
template < > struct if_ < na , na , na > { template < typename T1 , typename T2 , typename T3 , typename T4 = na , typename
#131
T5 = na > struct apply : if_ < T1 , T2 , T3 > { } ; } ; template < typename Tag > struct lambda < if_ < na , na , na > ,
#131
Tag > { typedef false_ is_le ; typedef if_ < na , na , na > result_ ; typedef if_ < na , na , na > type ; } ;

} }
#1 "./boost/mpl/and.hpp"
#1 "./boost/mpl/aux_/config/use_preprocessed.hpp"
#1 "./boost/mpl/aux_/nested_type_wknd.hpp"
#25
namespace boost { namespace mpl { namespace aux {
template < typename T > struct nested_type_wknd
: T :: type
{
} ;
} } }
#1 "./boost/mpl/aux_/include_preprocessed.hpp"
#1 "./boost/mpl/aux_/config/compiler.hpp"
#1 "./boost/preprocessor/stringize.hpp"
#1 "./boost/mpl/aux_/preprocessed/plain/and.hpp"
#12
namespace boost { namespace mpl {

namespace aux {

template < bool C_ , typename T1 , typename T2 , typename T3 , typename T4 >
struct and_impl
: false_
{
} ;

template < typename T1 , typename T2 , typename T3 , typename T4 >
struct and_impl < true , T1 , T2 , T3 , T4 >
: and_impl <
:: boost :: mpl :: aux :: nested_type_wknd < T1 > :: value
, T2 , T3 , T4
, true_
>
{
} ;

template < >
struct and_impl <
true
, true_ , true_ , true_ , true_
>
: true_
{
} ;

}

template <
typename T1 = na
, typename T2 = na
, typename T3 = true_ , typename T4 = true_ , typename T5 = true_
>
struct and_

: aux :: and_impl <
:: boost :: mpl :: aux :: nested_type_wknd < T1 > :: value
, T2 , T3 , T4 , T5
>

{
} ;





template < > struct and_ < na , na > { template < typename T1 , typename T2 , typename T3 = na , typename T4 = na , typename
#62
T5 = na > struct apply : and_ < T1 , T2 > { } ; } ; template < typename Tag > struct lambda < and_ < na , na > , Tag > {
#62
typedef false_ is_le ; typedef and_ < na , na > result_ ; typedef and_ < na , na > type ; } ;

} }
#1 "./boost/mpl/not.hpp"
#23
namespace boost { namespace mpl {

namespace aux {

template < long C_ >
struct not_impl
: bool_ < ! C_ >
{
} ;

}


template <
typename T = na
>
struct not_
: aux :: not_impl <
:: boost :: mpl :: aux :: nested_type_wknd < T > :: value
>
{

} ;

template < > struct not_ < na > { template < typename T1 , typename T2 = na , typename T3 = na , typename T4 = na , typename
#47
T5 = na > struct apply : not_ < T1 > { } ; } ; template < typename Tag > struct lambda < not_ < na > , Tag > { typedef false_
#47
is_le ; typedef not_ < na > result_ ; typedef not_ < na > type ; } ;

} }
#1 "./boost/ref.hpp"
#1 "./boost/utility/addressof.hpp"
#18
namespace boost
{

namespace detail
{

template < class T > struct addr_impl_ref
{
T & v_ ;

inline addr_impl_ref ( T & v ) : v_ ( v ) { }
inline operator T & ( ) const { return v_ ; }

private :
addr_impl_ref & operator = ( const addr_impl_ref & ) ;
} ;

template < class T > struct addressof_impl
{
static inline T * f ( T & v , long )
{
return reinterpret_cast < T * > (
& const_cast < char & > ( reinterpret_cast < const volatile char & > ( v ) ) ) ;
}

static inline T * f ( T * v , int )
{
return v ;
}
} ;

}

template < class T > T * addressof ( T & v )
{


return boost :: detail :: addressof_impl < T > :: f ( v , 0 ) ;
#62
}



namespace detail
{

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

}

template < class T , std :: size_t N >
typename detail :: addressof_addp < T [ N ] > :: type addressof ( T ( & t ) [ N ] )
{
return & t ;
}
#100
}
#29 "./boost/ref.hpp"
namespace boost
{

template < class T > class reference_wrapper
{
public :
typedef T type ;
#43
explicit reference_wrapper ( T & t ) : t_ ( boost :: addressof ( t ) ) { }



operator T & ( ) const { return * t_ ; }

T & get ( ) const { return * t_ ; }

T * get_pointer ( ) const { return t_ ; }

private :

T * t_ ;
} ;
#64
template < class T > inline reference_wrapper < T > const ref ( T & t )
{
return reference_wrapper < T > ( t ) ;
}

template < class T > inline reference_wrapper < T const > const cref ( T const & t )
{
return reference_wrapper < T const > ( t ) ;
}





template < typename T >
class is_reference_wrapper
: public mpl :: false_
{
} ;

template < typename T >
class unwrap_reference
{
public :
typedef T type ;
} ;
#106
template < typename T > class is_reference_wrapper < reference_wrapper < T > > : public mpl :: true_ { } ; template < typename
#106
T > class unwrap_reference < reference_wrapper < T > > { public : typedef T type ; } ;

template < typename T > class is_reference_wrapper < reference_wrapper < T > const > : public mpl :: true_ { } ; template
#108
< typename T > class unwrap_reference < reference_wrapper < T > const > { public : typedef T type ; } ;
template < typename T > class is_reference_wrapper < reference_wrapper < T > volatile > : public mpl :: true_ { } ; template
#109
< typename T > class unwrap_reference < reference_wrapper < T > volatile > { public : typedef T type ; } ;
template < typename T > class is_reference_wrapper < reference_wrapper < T > const volatile > : public mpl :: true_ { } ;
#110
template < typename T > class unwrap_reference < reference_wrapper < T > const volatile > { public : typedef T type ; } ;
#110

#176
template < class T > inline typename unwrap_reference < T > :: type &
unwrap_ref ( T & t )
{
return t ;
}

template < class T > inline T * get_pointer ( reference_wrapper < T > const & r )
{
return r . get_pointer ( ) ;
}

}
#39 "./boost/regex/v4/regex_format.hpp"
namespace boost {
#55
template < class BidiIterator , class Allocator = typename std :: vector < sub_match < BidiIterator > > :: allocator_type
#55
>
class match_results ;

namespace re_detail {
#65
template < class charT >
struct trivial_format_traits
{
typedef charT char_type ;

static std :: ptrdiff_t length ( const charT * p )
{
return global_length ( p ) ;
}
static charT tolower ( charT c )
{
return :: boost :: re_detail :: global_lower ( c ) ;
}
static charT toupper ( charT c )
{
return :: boost :: re_detail :: global_upper ( c ) ;
}
static int value ( const charT c , int radix )
{
int result = global_value ( c ) ;
return result >= radix ? - 1 : result ;
}
int toi ( const charT * & p1 , const charT * p2 , int radix ) const
{
return global_toi ( p1 , p2 , radix , * this ) ;
}
} ;

template < class OutputIterator , class Results , class traits , class ForwardIter >
class basic_regex_formatter
{
public :
typedef typename traits :: char_type char_type ;
basic_regex_formatter ( OutputIterator o , const Results & r , const traits & t )
: m_traits ( t ) , m_results ( r ) , m_out ( o ) , m_state ( output_copy ) , m_restore_state ( output_copy ) , m_have_conditional
#99
( false ) { }
OutputIterator format ( ForwardIter p1 , ForwardIter p2 , match_flag_type f ) ;
OutputIterator format ( ForwardIter p1 , match_flag_type f )
{
return format ( p1 , p1 + m_traits . length ( p1 ) , f ) ;
}
private :
typedef typename Results :: value_type sub_match_type ;
enum output_state
{
output_copy ,
output_next_lower ,
output_next_upper ,
output_lower ,
output_upper ,
output_none
} ;

void put ( char_type c ) ;
void put ( const sub_match_type & sub ) ;
void format_all ( ) ;
void format_perl ( ) ;
void format_escape ( ) ;
void format_conditional ( ) ;
void format_until_scope_end ( ) ;
bool handle_perl_verb ( bool have_brace ) ;

inline typename Results :: value_type const & get_named_sub ( ForwardIter i , ForwardIter j , const mpl :: false_ & )
{
std :: vector < char_type > v ( i , j ) ;
return ( i != j ) ? this -> m_results . named_subexpression ( & v [ 0 ] , & v [ 0 ] + v . size ( ) )
: this -> m_results . named_subexpression ( static_cast < const char_type * > ( 0 ) , static_cast < const char_type * > (
#130
0 ) ) ;
}
inline typename Results :: value_type const & get_named_sub ( ForwardIter i , ForwardIter j , const mpl :: true_ & )
{
return this -> m_results . named_subexpression ( i , j ) ;
}
inline typename Results :: value_type const & get_named_sub ( ForwardIter i , ForwardIter j )
{
typedef typename boost :: is_convertible < ForwardIter , const char_type * > :: type tag_type ;
return get_named_sub ( i , j , tag_type ( ) ) ;
}
inline int get_named_sub_index ( ForwardIter i , ForwardIter j , const mpl :: false_ & )
{
std :: vector < char_type > v ( i , j ) ;
return ( i != j ) ? this -> m_results . named_subexpression_index ( & v [ 0 ] , & v [ 0 ] + v . size ( ) )
: this -> m_results . named_subexpression_index ( static_cast < const char_type * > ( 0 ) , static_cast < const char_type
#145
* > ( 0 ) ) ;
}
inline int get_named_sub_index ( ForwardIter i , ForwardIter j , const mpl :: true_ & )
{
return this -> m_results . named_subexpression_index ( i , j ) ;
}
inline int get_named_sub_index ( ForwardIter i , ForwardIter j )
{
typedef typename boost :: is_convertible < ForwardIter , const char_type * > :: type tag_type ;
return get_named_sub_index ( i , j , tag_type ( ) ) ;
}





inline int toi ( ForwardIter & i , ForwardIter j , int base , const boost :: mpl :: false_ & )
{
if ( i != j )
{
std :: vector < char_type > v ( i , j ) ;
const char_type * start = & v [ 0 ] ;
const char_type * pos = start ;
int r = m_traits . toi ( pos , & v [ 0 ] + v . size ( ) , base ) ;
std :: advance ( i , pos - start ) ;
return r ;
}
return - 1 ;
}



inline int toi ( ForwardIter & i , ForwardIter j , int base , const boost :: mpl :: true_ & )
{
return m_traits . toi ( i , j , base ) ;
}
inline int toi ( ForwardIter & i , ForwardIter j , int base )
{





typedef typename boost :: is_convertible < ForwardIter , const char_type * & > :: type tag_type ;
return toi ( i , j , base , tag_type ( ) ) ;

}

const traits & m_traits ;
const Results & m_results ;
OutputIterator m_out ;
ForwardIter m_position ;
ForwardIter m_end ;
match_flag_type m_flags ;
output_state m_state ;
output_state m_restore_state ;
bool m_have_conditional ;
private :
basic_regex_formatter ( const basic_regex_formatter & ) ;
basic_regex_formatter & operator = ( const basic_regex_formatter & ) ;
} ;

template < class OutputIterator , class Results , class traits , class ForwardIter >
OutputIterator basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: format ( ForwardIter p1 , ForwardIter
#208
p2 , match_flag_type f )
{
m_position = p1 ;
m_end = p2 ;
m_flags = f ;
format_all ( ) ;
return m_out ;
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
void basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: format_all ( )
{

while ( m_position != m_end )
{
switch ( * m_position )
{
case '&' :
if ( m_flags & :: boost :: regex_constants :: format_sed )
{
++ m_position ;
put ( m_results [ 0 ] ) ;
break ;
}
put ( * m_position ++ ) ;
break ;
case '\\' :
format_escape ( ) ;
break ;
case '(' :
if ( m_flags & boost :: regex_constants :: format_all )
{
++ m_position ;
bool have_conditional = m_have_conditional ;
m_have_conditional = false ;
format_until_scope_end ( ) ;
m_have_conditional = have_conditional ;
if ( m_position == m_end )
return ;
( ( void ) 0 ) ;
++ m_position ;
break ;
}
put ( * m_position ) ;
++ m_position ;
break ;
case ')' :
if ( m_flags & boost :: regex_constants :: format_all )
{
return ;
}
put ( * m_position ) ;
++ m_position ;
break ;
case ':' :
if ( ( m_flags & boost :: regex_constants :: format_all ) && m_have_conditional )
{
return ;
}
put ( * m_position ) ;
++ m_position ;
break ;
case '?' :
if ( m_flags & boost :: regex_constants :: format_all )
{
++ m_position ;
format_conditional ( ) ;
break ;
}
put ( * m_position ) ;
++ m_position ;
break ;
case '$' :
if ( ( m_flags & format_sed ) == 0 )
{
format_perl ( ) ;
break ;
}

( ( void ) 0 ) ;
default :
put ( * m_position ) ;
++ m_position ;
break ;
}
}
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
void basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: format_perl ( )
{




( ( void ) 0 ) ;



if ( ++ m_position == m_end )
{
-- m_position ;
put ( * m_position ) ;
++ m_position ;
return ;
}



bool have_brace = false ;
ForwardIter save_position = m_position ;
switch ( * m_position )
{
case '&' :
++ m_position ;
put ( this -> m_results [ 0 ] ) ;
break ;
case '`' :
++ m_position ;
put ( this -> m_results . prefix ( ) ) ;
break ;
case '\'' :
++ m_position ;
put ( this -> m_results . suffix ( ) ) ;
break ;
case '$' :
put ( * m_position ++ ) ;
break ;
case '+' :
if ( ( ++ m_position != m_end ) && ( * m_position == '{' ) )
{
ForwardIter base = ++ m_position ;
while ( ( m_position != m_end ) && ( * m_position != '}' ) ) ++ m_position ;
if ( m_position != m_end )
{

put ( get_named_sub ( base , m_position ) ) ;
++ m_position ;
break ;
}
else
{
m_position = -- base ;
}
}
put ( ( this -> m_results ) [ this -> m_results . size ( ) > 1 ? static_cast < int > ( this -> m_results . size ( ) - 1 )
#353
: 1 ] ) ;
break ;
case '{' :
have_brace = true ;
++ m_position ;
( ( void ) 0 ) ;
default :

{
std :: ptrdiff_t len = :: boost :: re_detail :: distance ( m_position , m_end ) ;

int v = this -> toi ( m_position , m_position + len , 10 ) ;
if ( ( v < 0 ) || ( have_brace && ( ( m_position == m_end ) || ( * m_position != '}' ) ) ) )
{

if ( ! handle_perl_verb ( have_brace ) )
{

m_position = -- save_position ;
put ( * m_position ) ;
++ m_position ;
}
break ;
}

put ( this -> m_results [ v ] ) ;
if ( have_brace )
++ m_position ;
}
}
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
bool basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: handle_perl_verb ( bool have_brace )
{



static const char_type MATCH [ ] = { 'M' , 'A' , 'T' , 'C' , 'H' } ;
static const char_type PREMATCH [ ] = { 'P' , 'R' , 'E' , 'M' , 'A' , 'T' , 'C' , 'H' } ;
static const char_type POSTMATCH [ ] = { 'P' , 'O' , 'S' , 'T' , 'M' , 'A' , 'T' , 'C' , 'H' } ;
static const char_type LAST_PAREN_MATCH [ ] = { 'L' , 'A' , 'S' , 'T' , '_' , 'P' , 'A' , 'R' , 'E' , 'N' , '_' , 'M' , 'A'
#394
, 'T' , 'C' , 'H' } ;
static const char_type LAST_SUBMATCH_RESULT [ ] = { 'L' , 'A' , 'S' , 'T' , '_' , 'S' , 'U' , 'B' , 'M' , 'A' , 'T' , 'C'
#395
, 'H' , '_' , 'R' , 'E' , 'S' , 'U' , 'L' , 'T' } ;
static const char_type LAST_SUBMATCH_RESULT_ALT [ ] = { '^' , 'N' } ;

if ( m_position == m_end )
return false ;
if ( have_brace && ( * m_position == '^' ) )
++ m_position ;

std :: ptrdiff_t max_len = m_end - m_position ;

if ( ( max_len >= 5 ) && std :: equal ( m_position , m_position + 5 , MATCH ) )
{
m_position += 5 ;
if ( have_brace )
{
if ( ( m_position != m_end ) && ( * m_position == '}' ) )
++ m_position ;
else
{
m_position -= 5 ;
return false ;
}
}
put ( this -> m_results [ 0 ] ) ;
return true ;
}
if ( ( max_len >= 8 ) && std :: equal ( m_position , m_position + 8 , PREMATCH ) )
{
m_position += 8 ;
if ( have_brace )
{
if ( ( m_position != m_end ) && ( * m_position == '}' ) )
++ m_position ;
else
{
m_position -= 8 ;
return false ;
}
}
put ( this -> m_results . prefix ( ) ) ;
return true ;
}
if ( ( max_len >= 9 ) && std :: equal ( m_position , m_position + 9 , POSTMATCH ) )
{
m_position += 9 ;
if ( have_brace )
{
if ( ( m_position != m_end ) && ( * m_position == '}' ) )
++ m_position ;
else
{
m_position -= 9 ;
return false ;
}
}
put ( this -> m_results . suffix ( ) ) ;
return true ;
}
if ( ( max_len >= 16 ) && std :: equal ( m_position , m_position + 16 , LAST_PAREN_MATCH ) )
{
m_position += 16 ;
if ( have_brace )
{
if ( ( m_position != m_end ) && ( * m_position == '}' ) )
++ m_position ;
else
{
m_position -= 16 ;
return false ;
}
}
put ( ( this -> m_results ) [ this -> m_results . size ( ) > 1 ? static_cast < int > ( this -> m_results . size ( ) - 1 )
#466
: 1 ] ) ;
return true ;
}
if ( ( max_len >= 20 ) && std :: equal ( m_position , m_position + 20 , LAST_SUBMATCH_RESULT ) )
{
m_position += 20 ;
if ( have_brace )
{
if ( ( m_position != m_end ) && ( * m_position == '}' ) )
++ m_position ;
else
{
m_position -= 20 ;
return false ;
}
}
put ( this -> m_results . get_last_closed_paren ( ) ) ;
return true ;
}
if ( ( max_len >= 2 ) && std :: equal ( m_position , m_position + 2 , LAST_SUBMATCH_RESULT_ALT ) )
{
m_position += 2 ;
if ( have_brace )
{
if ( ( m_position != m_end ) && ( * m_position == '}' ) )
++ m_position ;
else
{
m_position -= 2 ;
return false ;
}
}
put ( this -> m_results . get_last_closed_paren ( ) ) ;
return true ;
}
return false ;
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
void basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: format_escape ( )
{

if ( ++ m_position == m_end )
{
put ( static_cast < char_type > ( '\\' ) ) ;
return ;
}

switch ( * m_position )
{
case 'a' :
put ( static_cast < char_type > ( '\a' ) ) ;
++ m_position ;
break ;
case 'f' :
put ( static_cast < char_type > ( '\f' ) ) ;
++ m_position ;
break ;
case 'n' :
put ( static_cast < char_type > ( '\n' ) ) ;
++ m_position ;
break ;
case 'r' :
put ( static_cast < char_type > ( '\r' ) ) ;
++ m_position ;
break ;
case 't' :
put ( static_cast < char_type > ( '\t' ) ) ;
++ m_position ;
break ;
case 'v' :
put ( static_cast < char_type > ( '\v' ) ) ;
++ m_position ;
break ;
case 'x' :
if ( ++ m_position == m_end )
{
put ( static_cast < char_type > ( 'x' ) ) ;
return ;
}

if ( * m_position == static_cast < char_type > ( '{' ) )
{
++ m_position ;
int val = this -> toi ( m_position , m_end , 16 ) ;
if ( val < 0 )
{

put ( static_cast < char_type > ( 'x' ) ) ;
put ( static_cast < char_type > ( '{' ) ) ;
return ;
}
if ( ( m_position == m_end ) || ( * m_position != static_cast < char_type > ( '}' ) ) )
{
-- m_position ;
while ( * m_position != static_cast < char_type > ( '\\' ) )
-- m_position ;
++ m_position ;
put ( * m_position ++ ) ;
return ;
}
++ m_position ;
put ( static_cast < char_type > ( val ) ) ;
return ;
}
else
{
std :: ptrdiff_t len = :: boost :: re_detail :: distance ( m_position , m_end ) ;
len = ( std :: min ) ( static_cast < std :: ptrdiff_t > ( 2 ) , len ) ;
int val = this -> toi ( m_position , m_position + len , 16 ) ;
if ( val < 0 )
{
-- m_position ;
put ( * m_position ++ ) ;
return ;
}
put ( static_cast < char_type > ( val ) ) ;
}
break ;
case 'c' :
if ( ++ m_position == m_end )
{
-- m_position ;
put ( * m_position ++ ) ;
return ;
}
put ( static_cast < char_type > ( * m_position ++ % 32 ) ) ;
break ;
case 'e' :
put ( static_cast < char_type > ( 27 ) ) ;
++ m_position ;
break ;
default :

if ( ( m_flags & boost :: regex_constants :: format_sed ) == 0 )
{
bool breakout = false ;
switch ( * m_position )
{
case 'l' :
++ m_position ;
m_restore_state = m_state ;
m_state = output_next_lower ;
breakout = true ;
break ;
case 'L' :
++ m_position ;
m_state = output_lower ;
breakout = true ;
break ;
case 'u' :
++ m_position ;
m_restore_state = m_state ;
m_state = output_next_upper ;
breakout = true ;
break ;
case 'U' :
++ m_position ;
m_state = output_upper ;
breakout = true ;
break ;
case 'E' :
++ m_position ;
m_state = output_copy ;
breakout = true ;
break ;
}
if ( breakout )
break ;
}

std :: ptrdiff_t len = :: boost :: re_detail :: distance ( m_position , m_end ) ;
len = ( std :: min ) ( static_cast < std :: ptrdiff_t > ( 1 ) , len ) ;
int v = this -> toi ( m_position , m_position + len , 10 ) ;
if ( ( v > 0 ) || ( ( v == 0 ) && ( m_flags & :: boost :: regex_constants :: format_sed ) ) )
{
put ( m_results [ v ] ) ;
break ;
}
else if ( v == 0 )
{

-- m_position ;
len = :: boost :: re_detail :: distance ( m_position , m_end ) ;
len = ( std :: min ) ( static_cast < std :: ptrdiff_t > ( 4 ) , len ) ;
v = this -> toi ( m_position , m_position + len , 8 ) ;
( ( void ) 0 ) ;
put ( static_cast < char_type > ( v ) ) ;
break ;
}

put ( * m_position ++ ) ;
break ;
}
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
void basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: format_conditional ( )
{
if ( m_position == m_end )
{

put ( static_cast < char_type > ( '?' ) ) ;
return ;
}
int v ;
if ( * m_position == '{' )
{
ForwardIter base = m_position ;
++ m_position ;
v = this -> toi ( m_position , m_end , 10 ) ;
if ( v < 0 )
{

while ( ( m_position != m_end ) && ( * m_position != '}' ) )
++ m_position ;
v = this -> get_named_sub_index ( base + 1 , m_position ) ;
}
if ( ( v < 0 ) || ( * m_position != '}' ) )
{
m_position = base ;

put ( static_cast < char_type > ( '?' ) ) ;
return ;
}

++ m_position ;
}
else
{
std :: ptrdiff_t len = :: boost :: re_detail :: distance ( m_position , m_end ) ;
len = ( std :: min ) ( static_cast < std :: ptrdiff_t > ( 2 ) , len ) ;
v = this -> toi ( m_position , m_position + len , 10 ) ;
}
if ( v < 0 )
{

put ( static_cast < char_type > ( '?' ) ) ;
return ;
}


if ( m_results [ v ] . matched )
{
m_have_conditional = true ;
format_all ( ) ;
m_have_conditional = false ;
if ( ( m_position != m_end ) && ( * m_position == static_cast < char_type > ( ':' ) ) )
{

++ m_position ;

output_state saved_state = m_state ;
m_state = output_none ;

format_until_scope_end ( ) ;

m_state = saved_state ;
}
}
else
{

output_state saved_state = m_state ;
m_state = output_none ;

m_have_conditional = true ;
format_all ( ) ;
m_have_conditional = false ;

m_state = saved_state ;
if ( ( m_position != m_end ) && ( * m_position == static_cast < char_type > ( ':' ) ) )
{

++ m_position ;

format_until_scope_end ( ) ;
}
}
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
void basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: format_until_scope_end ( )
{
do
{
format_all ( ) ;
if ( ( m_position == m_end ) || ( * m_position == static_cast < char_type > ( ')' ) ) )
return ;
put ( * m_position ++ ) ;
} while ( m_position != m_end ) ;
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
void basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: put ( char_type c )
{


switch ( this -> m_state )
{
case output_none :
return ;
case output_next_lower :
c = m_traits . tolower ( c ) ;
this -> m_state = m_restore_state ;
break ;
case output_next_upper :
c = m_traits . toupper ( c ) ;
this -> m_state = m_restore_state ;
break ;
case output_lower :
c = m_traits . tolower ( c ) ;
break ;
case output_upper :
c = m_traits . toupper ( c ) ;
break ;
default :
break ;
}
* m_out = c ;
++ m_out ;
}

template < class OutputIterator , class Results , class traits , class ForwardIter >
void basic_regex_formatter < OutputIterator , Results , traits , ForwardIter > :: put ( const sub_match_type & sub )
{
typedef typename sub_match_type :: iterator iterator_type ;
iterator_type i = sub . first ;
while ( i != sub . second )
{
put ( * i ) ;
++ i ;
}
}

template < class S >
class string_out_iterator

: public std :: iterator < std :: output_iterator_tag , typename S :: value_type >

{
S * out ;
public :
string_out_iterator ( S & s ) : out ( & s ) { }
string_out_iterator & operator ++ ( ) { return * this ; }
string_out_iterator & operator ++ ( int ) { return * this ; }
string_out_iterator & operator * ( ) { return * this ; }
string_out_iterator & operator = ( typename S :: value_type v )
{
out -> append ( 1 , v ) ;
return * this ;
}
#826
} ;

template < class OutputIterator , class Iterator , class Alloc , class ForwardIter , class traits >
OutputIterator regex_format_imp ( OutputIterator out ,
const match_results < Iterator , Alloc > & m ,
ForwardIter p1 , ForwardIter p2 ,
match_flag_type flags ,
const traits & t
)
{
if ( flags & regex_constants :: format_literal )
{
return re_detail :: copy ( p1 , p2 , out ) ;
}

re_detail :: basic_regex_formatter <
OutputIterator ,
match_results < Iterator , Alloc > ,
traits , ForwardIter > f ( out , m , t ) ;
return f . format ( p1 , p2 , flags ) ;
}



template < typename T , typename fallback_ = boost :: mpl :: bool_ < false > > struct has_const_iterator { struct gcc_3_2_wknd
#850
{ template < typename U > static boost :: mpl :: aux :: yes_tag test ( boost :: mpl :: aux :: type_wrapper < U > const volatile
#850
* , boost :: mpl :: aux :: type_wrapper < typename U :: const_iterator > * = 0 ) ; static boost :: mpl :: aux :: no_tag test
#850
( ... ) ; } ; typedef boost :: mpl :: aux :: type_wrapper < T > t_ ; static const bool value = sizeof ( gcc_3_2_wknd :: test
#850
( static_cast < t_ * > ( 0 ) ) ) == sizeof ( boost :: mpl :: aux :: yes_tag ) ; typedef boost :: mpl :: bool_ < value > type
#850
; } ;

struct any_type
{
template < class T >
any_type ( const T & ) ;
template < class T , class U >
any_type ( const T & , const U & ) ;
template < class T , class U , class V >
any_type ( const T & , const U & , const V & ) ;
} ;
typedef char no_type ;
typedef char ( & unary_type ) [ 2 ] ;
typedef char ( & binary_type ) [ 3 ] ;
typedef char ( & ternary_type ) [ 4 ] ;

no_type check_is_formatter ( unary_type , binary_type , ternary_type ) ;
template < typename T >
unary_type check_is_formatter ( T const & , binary_type , ternary_type ) ;
template < typename T >
binary_type check_is_formatter ( unary_type , T const & , ternary_type ) ;
template < typename T , typename U >
binary_type check_is_formatter ( T const & , U const & , ternary_type ) ;
template < typename T >
ternary_type check_is_formatter ( unary_type , binary_type , T const & ) ;
template < typename T , typename U >
ternary_type check_is_formatter ( T const & , binary_type , U const & ) ;
template < typename T , typename U >
ternary_type check_is_formatter ( unary_type , T const & , U const & ) ;
template < typename T , typename U , typename V >
ternary_type check_is_formatter ( T const & , U const & , V const & ) ;

struct unary_binary_ternary
{
typedef unary_type ( * unary_fun ) ( any_type ) ;
typedef binary_type ( * binary_fun ) ( any_type , any_type ) ;
typedef ternary_type ( * ternary_fun ) ( any_type , any_type , any_type ) ;
operator unary_fun ( ) ;
operator binary_fun ( ) ;
operator ternary_fun ( ) ;
} ;

template < typename Formatter , bool IsFunction = boost :: is_function < Formatter > :: value >
struct formatter_wrapper
: Formatter
, unary_binary_ternary
{
formatter_wrapper ( ) { }
} ;

template < typename Formatter >
struct formatter_wrapper < Formatter , true >
: unary_binary_ternary
{
operator Formatter * ( ) ;
} ;

template < typename Formatter >
struct formatter_wrapper < Formatter * , false >
: unary_binary_ternary
{
operator Formatter * ( ) ;
} ;

template < class F , class M , class O >
struct format_traits_imp
{
private :



typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( ( :: boost :: is_pointer
#921
< F > :: value || :: boost :: is_function < F > :: value || :: boost :: is_class < F > :: value ) ) > ) > boost_static_assert_typedef_921
#921
;
static formatter_wrapper < typename unwrap_reference < F > :: type > f ;
static M m ;
static O out ;
static boost :: regex_constants :: match_flag_type flags ;
public :
static const int value = sizeof ( check_is_formatter ( f ( m ) , f ( m , out ) , f ( m , out , flags ) ) ) ;
} ;

template < class F , class M , class O >
struct format_traits
{
public :
#943
typedef typename boost :: mpl :: if_ <
boost :: mpl :: and_ < boost :: is_pointer < F > , boost :: mpl :: not_ < boost :: is_function < typename boost :: remove_pointer
#944
< F > :: type > > > ,
boost :: mpl :: int_ < 0 > ,
typename boost :: mpl :: if_ <
has_const_iterator < F > ,
boost :: mpl :: int_ < 1 > ,
boost :: mpl :: int_ < format_traits_imp < F , M , O > :: value >
> :: type
> :: type type ;




typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( boost :: is_class < F
#956
> :: value && ! has_const_iterator < F > :: value ? ( type :: value > 1 ) : true ) > ) > boost_static_assert_typedef_956
#956
;
} ;
#983
template < class Base , class Match >
struct format_functor3
{
format_functor3 ( Base b ) : func ( b ) { }
template < class OutputIter >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type f )
{
return boost :: unwrap_ref ( func ) ( m , i , f ) ;
}
template < class OutputIter , class Traits >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type f , const Traits &
#993
)
{
return ( * this ) ( m , i , f ) ;
}
private :
Base func ;
format_functor3 ( const format_functor3 & ) ;
format_functor3 & operator = ( const format_functor3 & ) ;
} ;

template < class Base , class Match >
struct format_functor2
{
format_functor2 ( Base b ) : func ( b ) { }
template < class OutputIter >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type )
{
return boost :: unwrap_ref ( func ) ( m , i ) ;
}
template < class OutputIter , class Traits >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type f , const Traits &
#1013
)
{
return ( * this ) ( m , i , f ) ;
}
private :
Base func ;
format_functor2 ( const format_functor2 & ) ;
format_functor2 & operator = ( const format_functor2 & ) ;
} ;

template < class Base , class Match >
struct format_functor1
{
format_functor1 ( Base b ) : func ( b ) { }

template < class S , class OutputIter >
OutputIter do_format_string ( const S & s , OutputIter i )
{
return re_detail :: copy ( s . begin ( ) , s . end ( ) , i ) ;
}
template < class S , class OutputIter >
inline OutputIter do_format_string ( const S * s , OutputIter i )
{
while ( s && * s )
{
* i = * s ;
++ i ;
++ s ;
}
return i ;
}
template < class OutputIter >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type )
{
return do_format_string ( boost :: unwrap_ref ( func ) ( m ) , i ) ;
}
template < class OutputIter , class Traits >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type f , const Traits &
#1050
)
{
return ( * this ) ( m , i , f ) ;
}
private :
Base func ;
format_functor1 ( const format_functor1 & ) ;
format_functor1 & operator = ( const format_functor1 & ) ;
} ;

template < class charT , class Match , class Traits >
struct format_functor_c_string
{
format_functor_c_string ( const charT * ps ) : func ( ps ) { }

template < class OutputIter >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type f , const Traits &
#1066
t = Traits ( ) )
{

const charT * end = func ;
while ( * end ) ++ end ;
return regex_format_imp ( i , m , func , end , f , t ) ;
}
private :
const charT * func ;
format_functor_c_string ( const format_functor_c_string & ) ;
format_functor_c_string & operator = ( const format_functor_c_string & ) ;
} ;

template < class Container , class Match , class Traits >
struct format_functor_container
{
format_functor_container ( const Container & c ) : func ( c ) { }

template < class OutputIter >
OutputIter operator ( ) ( const Match & m , OutputIter i , boost :: regex_constants :: match_flag_type f , const Traits &
#1085
t = Traits ( ) )
{

return re_detail :: regex_format_imp ( i , m , func . begin ( ) , func . end ( ) , f , t ) ;
}
private :
const Container & func ;
format_functor_container ( const format_functor_container & ) ;
format_functor_container & operator = ( const format_functor_container & ) ;
} ;

template < class Func , class Match , class OutputIterator , class Traits = re_detail :: trivial_format_traits < typename
#1096
Match :: char_type > >
struct compute_functor_type
{
typedef typename format_traits < Func , Match , OutputIterator > :: type tag ;
typedef typename boost :: remove_cv < typename boost :: remove_pointer < Func > :: type > :: type maybe_char_type ;

typedef typename mpl :: if_ <
:: boost :: is_same < tag , mpl :: int_ < 0 > > , format_functor_c_string < maybe_char_type , Match , Traits > ,
typename mpl :: if_ <
:: boost :: is_same < tag , mpl :: int_ < 1 > > , format_functor_container < Func , Match , Traits > ,
typename mpl :: if_ <
:: boost :: is_same < tag , mpl :: int_ < 2 > > , format_functor1 < Func , Match > ,
typename mpl :: if_ <
:: boost :: is_same < tag , mpl :: int_ < 3 > > , format_functor2 < Func , Match > ,
format_functor3 < Func , Match >
> :: type
> :: type
> :: type
> :: type type ;
} ;

}

template < class OutputIterator , class Iterator , class Allocator , class Functor >
inline OutputIterator regex_format ( OutputIterator out ,
const match_results < Iterator , Allocator > & m ,
Functor fmt ,
match_flag_type flags = format_all
)
{
return m . format ( out , fmt , flags ) ;
}

template < class Iterator , class Allocator , class Functor >
inline std :: basic_string < typename match_results < Iterator , Allocator > :: char_type > regex_format ( const match_results
#1130
< Iterator , Allocator > & m ,
Functor fmt ,
match_flag_type flags = format_all )
{
return m . format ( fmt , flags ) ;
}
#1148
}
#1 "./boost/regex/v4/match_results.hpp"
#33
namespace boost {
#42
namespace re_detail {

class named_subexpressions ;

}

template < class BidiIterator , class Allocator >
class match_results
{
private :

typedef std :: vector < sub_match < BidiIterator > , Allocator > vector_type ;



public :
typedef sub_match < BidiIterator > value_type ;

typedef typename Allocator :: const_reference const_reference ;



typedef const_reference reference ;
typedef typename vector_type :: const_iterator const_iterator ;
typedef const_iterator iterator ;
typedef typename re_detail :: regex_iterator_traits <
BidiIterator > :: difference_type difference_type ;
typedef typename Allocator :: size_type size_type ;
typedef Allocator allocator_type ;
typedef typename re_detail :: regex_iterator_traits <
BidiIterator > :: value_type char_type ;
typedef std :: basic_string < char_type > string_type ;
typedef re_detail :: named_subexpressions named_sub_type ;


explicit match_results ( const Allocator & a = Allocator ( ) )

: m_subs ( a ) , m_base ( ) , m_last_closed_paren ( 0 ) , m_is_singular ( true ) { }



match_results ( const match_results & m )
: m_subs ( m . m_subs ) , m_named_subs ( m . m_named_subs ) , m_last_closed_paren ( m . m_last_closed_paren ) , m_is_singular
#84
( m . m_is_singular )
{
if ( ! m_is_singular )
{
m_base = m . m_base ;
m_null = m . m_null ;
}
}
match_results & operator = ( const match_results & m )
{
m_subs = m . m_subs ;
m_named_subs = m . m_named_subs ;
m_last_closed_paren = m . m_last_closed_paren ;
m_is_singular = m . m_is_singular ;
if ( ! m_is_singular )
{
m_base = m . m_base ;
m_null = m . m_null ;
}
return * this ;
}
~ match_results ( ) { }


size_type size ( ) const
{ return empty ( ) ? 0 : m_subs . size ( ) - 2 ; }
size_type max_size ( ) const
{ return m_subs . max_size ( ) ; }
bool empty ( ) const
{ return m_subs . size ( ) < 2 ; }

difference_type length ( int sub = 0 ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
sub += 2 ;
if ( ( sub < ( int ) m_subs . size ( ) ) && ( sub > 0 ) )
return m_subs [ sub ] . length ( ) ;
return 0 ;
}
difference_type length ( const char_type * sub ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
const char_type * sub_end = sub ;
while ( * sub_end ) ++ sub_end ;
return length ( named_subexpression_index ( sub , sub_end ) ) ;
}
template < class charT >
difference_type length ( const charT * sub ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
const charT * sub_end = sub ;
while ( * sub_end ) ++ sub_end ;
return length ( named_subexpression_index ( sub , sub_end ) ) ;
}
template < class charT , class Traits , class A >
difference_type length ( const std :: basic_string < charT , Traits , A > & sub ) const
{
return length ( sub . c_str ( ) ) ;
}
difference_type position ( size_type sub = 0 ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
sub += 2 ;
if ( sub < m_subs . size ( ) )
{
const sub_match < BidiIterator > & s = m_subs [ sub ] ;
if ( s . matched || ( sub == 2 ) )
{
return :: boost :: re_detail :: distance ( ( BidiIterator ) ( m_base ) , ( BidiIterator ) ( s . first ) ) ;
}
}
return ~ static_cast < difference_type > ( 0 ) ;
}
difference_type position ( const char_type * sub ) const
{
const char_type * sub_end = sub ;
while ( * sub_end ) ++ sub_end ;
return position ( named_subexpression_index ( sub , sub_end ) ) ;
}
template < class charT >
difference_type position ( const charT * sub ) const
{
const charT * sub_end = sub ;
while ( * sub_end ) ++ sub_end ;
return position ( named_subexpression_index ( sub , sub_end ) ) ;
}
template < class charT , class Traits , class A >
difference_type position ( const std :: basic_string < charT , Traits , A > & sub ) const
{
return position ( sub . c_str ( ) ) ;
}
string_type str ( int sub = 0 ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
sub += 2 ;
string_type result ;
if ( sub < ( int ) m_subs . size ( ) && ( sub > 0 ) )
{
const sub_match < BidiIterator > & s = m_subs [ sub ] ;
if ( s . matched )
{
result = s . str ( ) ;
}
}
return result ;
}
string_type str ( const char_type * sub ) const
{
return ( * this ) [ sub ] . str ( ) ;
}
template < class Traits , class A >
string_type str ( const std :: basic_string < char_type , Traits , A > & sub ) const
{
return ( * this ) [ sub ] . str ( ) ;
}
template < class charT >
string_type str ( const charT * sub ) const
{
return ( * this ) [ sub ] . str ( ) ;
}
template < class charT , class Traits , class A >
string_type str ( const std :: basic_string < charT , Traits , A > & sub ) const
{
return ( * this ) [ sub ] . str ( ) ;
}
const_reference operator [ ] ( int sub ) const
{
if ( m_is_singular && m_subs . empty ( ) )
raise_logic_error ( ) ;
sub += 2 ;
if ( sub < ( int ) m_subs . size ( ) && ( sub >= 0 ) )
{
return m_subs [ sub ] ;
}
return m_null ;
}



const_reference named_subexpression ( const char_type * i , const char_type * j ) const
{



if ( m_is_singular )
raise_logic_error ( ) ;
re_detail :: named_subexpressions :: range_type r = m_named_subs -> equal_range ( i , j ) ;
while ( ( r . first != r . second ) && ( ( * this ) [ r . first -> index ] . matched == false ) )
++ r . first ;
return r . first != r . second ? ( * this ) [ r . first -> index ] : m_null ;
}
template < class charT >
const_reference named_subexpression ( const charT * i , const charT * j ) const
{
typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( sizeof ( charT ) <= sizeof
#243
( char_type ) ) > ) > boost_static_assert_typedef_243 ;
if ( i == j )
return m_null ;
std :: vector < char_type > s ;
while ( i != j )
s . insert ( s . end ( ) , * i ++ ) ;
return named_subexpression ( & * s . begin ( ) , & * s . begin ( ) + s . size ( ) ) ;
}
int named_subexpression_index ( const char_type * i , const char_type * j ) const
{





if ( m_is_singular )
raise_logic_error ( ) ;
re_detail :: named_subexpressions :: range_type s , r ;
s = r = m_named_subs -> equal_range ( i , j ) ;
while ( ( r . first != r . second ) && ( ( * this ) [ r . first -> index ] . matched == false ) )
++ r . first ;
if ( r . first == r . second )
r = s ;
return r . first != r . second ? r . first -> index : - 20 ;
}
template < class charT >
int named_subexpression_index ( const charT * i , const charT * j ) const
{
typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( sizeof ( charT ) <= sizeof
#271
( char_type ) ) > ) > boost_static_assert_typedef_271 ;
if ( i == j )
return - 20 ;
std :: vector < char_type > s ;
while ( i != j )
s . insert ( s . end ( ) , * i ++ ) ;
return named_subexpression_index ( & * s . begin ( ) , & * s . begin ( ) + s . size ( ) ) ;
}
template < class Traits , class A >
const_reference operator [ ] ( const std :: basic_string < char_type , Traits , A > & s ) const
{
return named_subexpression ( s . c_str ( ) , s . c_str ( ) + s . size ( ) ) ;
}
const_reference operator [ ] ( const char_type * p ) const
{
const char_type * e = p ;
while ( * e ) ++ e ;
return named_subexpression ( p , e ) ;
}

template < class charT >
const_reference operator [ ] ( const charT * p ) const
{
typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( sizeof ( charT ) <= sizeof
#294
( char_type ) ) > ) > boost_static_assert_typedef_294 ;
if ( * p == 0 )
return m_null ;
std :: vector < char_type > s ;
while ( * p )
s . insert ( s . end ( ) , * p ++ ) ;
return named_subexpression ( & * s . begin ( ) , & * s . begin ( ) + s . size ( ) ) ;
}
template < class charT , class Traits , class A >
const_reference operator [ ] ( const std :: basic_string < charT , Traits , A > & ns ) const
{
typedef :: boost :: static_assert_test < sizeof ( :: boost :: STATIC_ASSERTION_FAILURE < ( bool ) ( sizeof ( charT ) <= sizeof
#305
( char_type ) ) > ) > boost_static_assert_typedef_305 ;
if ( ns . empty ( ) )
return m_null ;
std :: vector < char_type > s ;
for ( unsigned i = 0 ; i < ns . size ( ) ; ++ i )
s . insert ( s . end ( ) , ns [ i ] ) ;
return named_subexpression ( & * s . begin ( ) , & * s . begin ( ) + s . size ( ) ) ;
}

const_reference prefix ( ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
return ( * this ) [ - 1 ] ;
}

const_reference suffix ( ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
return ( * this ) [ - 2 ] ;
}
const_iterator begin ( ) const
{
return ( m_subs . size ( ) > 2 ) ? ( m_subs . begin ( ) + 2 ) : m_subs . end ( ) ;
}
const_iterator end ( ) const
{
return m_subs . end ( ) ;
}

template < class OutputIterator , class Functor >
OutputIterator format ( OutputIterator out ,
Functor fmt ,
match_flag_type flags = format_default ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
typedef typename re_detail :: compute_functor_type < Functor , match_results < BidiIterator , Allocator > , OutputIterator
#343
> :: type F ;
F func ( fmt ) ;
return func ( * this , out , flags ) ;
}
template < class Functor >
string_type format ( Functor fmt , match_flag_type flags = format_default ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
std :: basic_string < char_type > result ;
re_detail :: string_out_iterator < std :: basic_string < char_type > > i ( result ) ;

typedef typename re_detail :: compute_functor_type < Functor , match_results < BidiIterator , Allocator > , re_detail ::
#355
string_out_iterator < std :: basic_string < char_type > > > :: type F ;
F func ( fmt ) ;

func ( * this , i , flags ) ;
return result ;
}

template < class OutputIterator , class Functor , class RegexT >
OutputIterator format ( OutputIterator out ,
Functor fmt ,
match_flag_type flags ,
const RegexT & re ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
typedef :: boost :: regex_traits_wrapper < typename RegexT :: traits_type > traits_type ;
typedef typename re_detail :: compute_functor_type < Functor , match_results < BidiIterator , Allocator > , OutputIterator
#371
, traits_type > :: type F ;
F func ( fmt ) ;
return func ( * this , out , flags , re . get_traits ( ) ) ;
}
template < class RegexT , class Functor >
string_type format ( Functor fmt ,
match_flag_type flags ,
const RegexT & re ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
typedef :: boost :: regex_traits_wrapper < typename RegexT :: traits_type > traits_type ;
std :: basic_string < char_type > result ;
re_detail :: string_out_iterator < std :: basic_string < char_type > > i ( result ) ;

typedef typename re_detail :: compute_functor_type < Functor , match_results < BidiIterator , Allocator > , re_detail ::
#386
string_out_iterator < std :: basic_string < char_type > > , traits_type > :: type F ;
F func ( fmt ) ;

func ( * this , i , flags , re . get_traits ( ) ) ;
return result ;
}

const_reference get_last_closed_paren ( ) const
{
if ( m_is_singular )
raise_logic_error ( ) ;
return m_last_closed_paren == 0 ? m_null : ( * this ) [ m_last_closed_paren ] ;
}

allocator_type get_allocator ( ) const
{

return m_subs . get_allocator ( ) ;



}
void swap ( match_results & that )
{
std :: swap ( m_subs , that . m_subs ) ;
std :: swap ( m_named_subs , that . m_named_subs ) ;
std :: swap ( m_last_closed_paren , that . m_last_closed_paren ) ;
if ( m_is_singular )
{
if ( ! that . m_is_singular )
{
m_base = that . m_base ;
m_null = that . m_null ;
}
}
else if ( that . m_is_singular )
{
that . m_base = m_base ;
that . m_null = m_null ;
}
else
{
std :: swap ( m_base , that . m_base ) ;
std :: swap ( m_null , that . m_null ) ;
}
std :: swap ( m_is_singular , that . m_is_singular ) ;
}
bool operator == ( const match_results & that ) const
{
if ( m_is_singular )
{
return that . m_is_singular ;
}
else if ( that . m_is_singular )
{
return false ;
}
return ( m_subs == that . m_subs ) && ( m_base == that . m_base ) && ( m_last_closed_paren == that . m_last_closed_paren
#443
) ;
}
bool operator != ( const match_results & that ) const
{ return ! ( * this == that ) ; }
#461
void set_second ( BidiIterator i )
{
( ( void ) 0 ) ;
m_subs [ 2 ] . second = i ;
m_subs [ 2 ] . matched = true ;
m_subs [ 0 ] . first = i ;
m_subs [ 0 ] . matched = ( m_subs [ 0 ] . first != m_subs [ 0 ] . second ) ;
m_null . first = i ;
m_null . second = i ;
m_null . matched = false ;
m_is_singular = false ;
}

void set_second ( BidiIterator i , size_type pos , bool m = true , bool escape_k = false )
{
if ( pos )
m_last_closed_paren = static_cast < int > ( pos ) ;
pos += 2 ;
( ( void ) 0 ) ;
m_subs [ pos ] . second = i ;
m_subs [ pos ] . matched = m ;
if ( ( pos == 2 ) && ! escape_k )
{
m_subs [ 0 ] . first = i ;
m_subs [ 0 ] . matched = ( m_subs [ 0 ] . first != m_subs [ 0 ] . second ) ;
m_null . first = i ;
m_null . second = i ;
m_null . matched = false ;
m_is_singular = false ;
}
}
void set_size ( size_type n , BidiIterator i , BidiIterator j )
{
value_type v ( j ) ;
size_type len = m_subs . size ( ) ;
if ( len > n + 2 )
{
m_subs . erase ( m_subs . begin ( ) + n + 2 , m_subs . end ( ) ) ;
std :: fill ( m_subs . begin ( ) , m_subs . end ( ) , v ) ;
}
else
{
std :: fill ( m_subs . begin ( ) , m_subs . end ( ) , v ) ;
if ( n + 2 != len )
m_subs . insert ( m_subs . end ( ) , n + 2 - len , v ) ;
}
m_subs [ 1 ] . first = i ;
m_last_closed_paren = 0 ;
}
void set_base ( BidiIterator pos )
{
m_base = pos ;
}
BidiIterator base ( ) const
{
return m_base ;
}
void set_first ( BidiIterator i )
{
( ( void ) 0 ) ;

m_subs [ 1 ] . second = i ;
m_subs [ 1 ] . matched = ( m_subs [ 1 ] . first != i ) ;

m_subs [ 2 ] . first = i ;

for ( size_type n = 3 ; n < m_subs . size ( ) ; ++ n )
{
m_subs [ n ] . first = m_subs [ n ] . second = m_subs [ 0 ] . second ;
m_subs [ n ] . matched = false ;
}
}
void set_first ( BidiIterator i , size_type pos , bool escape_k = false )
{
( ( void ) 0 ) ;
if ( pos || escape_k )
{
m_subs [ pos + 2 ] . first = i ;
if ( escape_k )
{
m_subs [ 1 ] . second = i ;
m_subs [ 1 ] . matched = ( m_subs [ 1 ] . first != m_subs [ 1 ] . second ) ;
}
}
else
set_first ( i ) ;
}
void maybe_assign ( const match_results < BidiIterator , Allocator > & m ) ;

void set_named_subs ( boost :: shared_ptr < named_sub_type > subs )
{
m_named_subs = subs ;
}

private :



static void raise_logic_error ( )
{
std :: logic_error e ( "Attempt to access an uninitialzed boost::match_results<> class." ) ;
boost :: throw_exception ( e ) ;
}


vector_type m_subs ;
BidiIterator m_base ;
sub_match < BidiIterator > m_null ;
boost :: shared_ptr < named_sub_type > m_named_subs ;
int m_last_closed_paren ;
bool m_is_singular ;
} ;

template < class BidiIterator , class Allocator >
void match_results < BidiIterator , Allocator > :: maybe_assign ( const match_results < BidiIterator , Allocator > & m )
#575

{
if ( m_is_singular )
{
* this = m ;
return ;
}
const_iterator p1 , p2 ;
p1 = begin ( ) ;
p2 = m . begin ( ) ;
#595
BidiIterator l_end = this -> suffix ( ) . second ;
BidiIterator l_base = ( p1 -> first == l_end ) ? this -> prefix ( ) . first : ( * this ) [ 0 ] . first ;
difference_type len1 = 0 ;
difference_type len2 = 0 ;
difference_type base1 = 0 ;
difference_type base2 = 0 ;
std :: size_t i ;
for ( i = 0 ; i < size ( ) ; ++ i , ++ p1 , ++ p2 )
{
#611
if ( p1 -> first == l_end )
{
if ( p2 -> first != l_end )
{


base1 = 1 ;
base2 = 0 ;
break ;
}
else
{


if ( ( p1 -> matched == false ) && ( p2 -> matched == true ) )
break ;
if ( ( p1 -> matched == true ) && ( p2 -> matched == false ) )
return ;
continue ;
}
}
else if ( p2 -> first == l_end )
{

return ;
}
base1 = :: boost :: re_detail :: distance ( l_base , p1 -> first ) ;
base2 = :: boost :: re_detail :: distance ( l_base , p2 -> first ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
if ( base1 < base2 ) return ;
if ( base2 < base1 ) break ;

len1 = :: boost :: re_detail :: distance ( ( BidiIterator ) p1 -> first , ( BidiIterator ) p1 -> second ) ;
len2 = :: boost :: re_detail :: distance ( ( BidiIterator ) p2 -> first , ( BidiIterator ) p2 -> second ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
if ( ( len1 != len2 ) || ( ( p1 -> matched == false ) && ( p2 -> matched == true ) ) )
break ;
if ( ( p1 -> matched == true ) && ( p2 -> matched == false ) )
return ;
}
if ( i == size ( ) )
return ;
if ( base2 < base1 )
* this = m ;
else if ( ( len2 > len1 ) || ( ( p1 -> matched == false ) && ( p2 -> matched == true ) ) )
* this = m ;
}

template < class BidiIterator , class Allocator >
void swap ( match_results < BidiIterator , Allocator > & a , match_results < BidiIterator , Allocator > & b )
{
a . swap ( b ) ;
}


template < class charT , class traits , class BidiIterator , class Allocator >
std :: basic_ostream < charT , traits > &
operator << ( std :: basic_ostream < charT , traits > & os ,
const match_results < BidiIterator , Allocator > & s )
{
return ( os << s . str ( ) ) ;
}
#687
}
#1 "./boost/regex/v4/protected_call.hpp"
#34
namespace boost {
namespace re_detail {

class abstract_protected_call
{
public :
bool execute ( ) const ;

virtual ~ abstract_protected_call ( ) { }
private :
virtual bool call ( ) const = 0 ;
} ;

template < class T >
class concrete_protected_call
: public abstract_protected_call
{
public :
typedef bool ( T :: * proc_type ) ( ) ;
concrete_protected_call ( T * o , proc_type p )
: obj ( o ) , proc ( p ) { }
private :
virtual bool call ( ) const ;
T * obj ;
proc_type proc ;
} ;

template < class T >
bool concrete_protected_call < T > :: call ( ) const
{
return ( obj ->* proc ) ( ) ;
}

}
}
#1 "./boost/regex/v4/perl_matcher.hpp"
#1 "./boost/regex/v4/iterator_category.hpp"
#28
namespace boost {
namespace detail {

template < class I >
struct is_random_imp
{

private :
typedef typename std :: iterator_traits < I > :: iterator_category cat ;
public :
static const bool value = ( :: boost :: is_convertible < cat * , std :: random_access_iterator_tag * > :: value ) ;



} ;

template < class I >
struct is_random_pointer_imp
{
static const bool value = true ;
} ;

template < bool is_pointer_type >
struct is_random_imp_selector
{
template < class I >
struct rebind
{
typedef is_random_imp < I > type ;
} ;
} ;

template < >
struct is_random_imp_selector < true >
{
template < class I >
struct rebind
{
typedef is_random_pointer_imp < I > type ;
} ;
} ;

}

template < class I >
struct is_random_access_iterator
{
private :
typedef detail :: is_random_imp_selector < :: boost :: is_pointer < I > :: value > selector ;
typedef typename selector :: template rebind < I > bound_type ;
typedef typename bound_type :: type answer ;
public :
static const bool value = answer :: value ;
} ;


template < class I >
const bool is_random_access_iterator < I > :: value ;


}
#33 "./boost/regex/v4/perl_matcher.hpp"
namespace boost {
namespace re_detail {




void verify_options ( boost :: regex_constants :: syntax_option_type ef , match_flag_type mf ) ;



template < class charT >
inline bool can_start ( charT c , const unsigned char * map , unsigned char mask )
{
return ( ( c < static_cast < charT > ( 0 ) ) ? true : ( ( c >= static_cast < charT > ( 1 << 8 ) ) ? true : map [ c ] & mask
#46
) ) ;
}
inline bool can_start ( char c , const unsigned char * map , unsigned char mask )
{
return map [ ( unsigned char ) c ] & mask ;
}
inline bool can_start ( signed char c , const unsigned char * map , unsigned char mask )
{
return map [ ( unsigned char ) c ] & mask ;
}
inline bool can_start ( unsigned char c , const unsigned char * map , unsigned char mask )
{
return map [ c ] & mask ;
}
inline bool can_start ( unsigned short c , const unsigned char * map , unsigned char mask )
{
return ( ( c >= ( 1 << 8 ) ) ? true : map [ c ] & mask ) ;
}
#73
inline bool can_start ( unsigned int c , const unsigned char * map , unsigned char mask )
{
return ( ( ( c >= static_cast < unsigned int > ( 1u << 8 ) ) ? true : map [ c ] & mask ) ) ;
}
#90
template < class C , class T , class A >
inline int string_compare ( const std :: basic_string < C , T , A > & s , const C * p )
{
if ( 0 == * p )
{
if ( s . empty ( ) || ( ( s . size ( ) == 1 ) && ( s [ 0 ] == 0 ) ) )
return 0 ;
}
return s . compare ( p ) ;
}
#121
template < class Seq , class C >
inline int string_compare ( const Seq & s , const C * p )
{
std :: size_t i = 0 ;
while ( ( i < s . size ( ) ) && ( p [ i ] == s [ i ] ) )
{
++ i ;
}
return ( i == s . size ( ) ) ? - p [ i ] : s [ i ] - p [ i ] ;
}


template < class charT >
inline const charT * re_skip_past_null ( const charT * p )
{
while ( * p != static_cast < charT > ( 0 ) ) ++ p ;
return ++ p ;
}

template < class iterator , class charT , class traits_type , class char_classT >
iterator re_is_set_member ( iterator next ,
iterator last ,
const re_set_long < char_classT > * set_ ,
const regex_data < charT , traits_type > & e , bool icase )
{
const charT * p = reinterpret_cast < const charT * > ( set_ + 1 ) ;
iterator ptr ;
unsigned int i ;


if ( next == last ) return next ;

typedef typename traits_type :: string_type traits_string_type ;
const :: boost :: regex_traits_wrapper < traits_type > & traits_inst = * ( e . m_ptraits ) ;



( void ) traits_inst ;



for ( i = 0 ; i < set_ -> csingles ; ++ i )
{
ptr = next ;
if ( * p == static_cast < charT > ( 0 ) )
{

if ( traits_inst . translate ( * ptr , icase ) != * p )
{
while ( * p == static_cast < charT > ( 0 ) ) ++ p ;
continue ;
}
return set_ -> isnot ? next : ( ptr == next ) ? ++ next : ptr ;
}
else
{
while ( * p && ( ptr != last ) )
{
if ( traits_inst . translate ( * ptr , icase ) != * p )
break ;
++ p ;
++ ptr ;
}

if ( * p == static_cast < charT > ( 0 ) )
return set_ -> isnot ? next : ( ptr == next ) ? ++ next : ptr ;

p = re_skip_past_null ( p ) ;
}
}

charT col = traits_inst . translate ( * next , icase ) ;


if ( set_ -> cranges || set_ -> cequivalents )
{
traits_string_type s1 ;


if ( set_ -> cranges )
{
if ( ( e . m_flags & regex_constants :: collate ) == 0 )
s1 . assign ( 1 , col ) ;
else
{
charT a [ 2 ] = { col , charT ( 0 ) , } ;
s1 = traits_inst . transform ( a , a + 1 ) ;
}
for ( i = 0 ; i < set_ -> cranges ; ++ i )
{
if ( string_compare ( s1 , p ) >= 0 )
{
do { ++ p ; } while ( * p ) ;
++ p ;
if ( string_compare ( s1 , p ) <= 0 )
return set_ -> isnot ? next : ++ next ;
}
else
{

do { ++ p ; } while ( * p ) ;
++ p ;
}

do { ++ p ; } while ( * p ) ;
++ p ;
}
}


if ( set_ -> cequivalents )
{
charT a [ 2 ] = { col , charT ( 0 ) , } ;
s1 = traits_inst . transform_primary ( a , a + 1 ) ;
for ( i = 0 ; i < set_ -> cequivalents ; ++ i )
{
if ( string_compare ( s1 , p ) == 0 )
return set_ -> isnot ? next : ++ next ;

do { ++ p ; } while ( * p ) ;
++ p ;
}
}
}
if ( traits_inst . isctype ( col , set_ -> cclasses ) == true )
return set_ -> isnot ? next : ++ next ;
if ( ( set_ -> cnclasses != 0 ) && ( traits_inst . isctype ( col , set_ -> cnclasses ) == false ) )
return set_ -> isnot ? next : ++ next ;
return set_ -> isnot ? ++ next : next ;
}

template < class BidiIterator >
class repeater_count
{
repeater_count * * stack ;
repeater_count * next ;
int state_id ;
std :: size_t count ;
BidiIterator start_pos ;
public :
repeater_count ( repeater_count * * s )
{
stack = s ;
next = 0 ;
state_id = - 1 ;
count = 0 ;
}
repeater_count ( int i , repeater_count * * s , BidiIterator start )
: start_pos ( start )
{
state_id = i ;
stack = s ;
next = * stack ;
* stack = this ;
if ( state_id > next -> state_id )
count = 0 ;
else
{
repeater_count * p = next ;
while ( p && ( p -> state_id != state_id ) )
p = p -> next ;
if ( p )
{
count = p -> count ;
start_pos = p -> start_pos ;
}
else
count = 0 ;
}
}
~ repeater_count ( )
{
if ( next )
* stack = next ;
}
std :: size_t get_count ( ) { return count ; }
int get_id ( ) { return state_id ; }
std :: size_t operator ++ ( ) { return ++ count ; }
bool check_null_repeat ( const BidiIterator & pos , std :: size_t max )
{



bool result = ( count == 0 ) ? false : ( pos == start_pos ) ;
if ( result )
count = max ;
else
start_pos = pos ;
return result ;
}
} ;

struct saved_state ;

enum saved_state_type
{
saved_type_end = 0 ,
saved_type_paren = 1 ,
saved_type_recurse = 2 ,
saved_type_assertion = 3 ,
saved_state_alt = 4 ,
saved_state_repeater_count = 5 ,
saved_state_extra_block = 6 ,
saved_state_greedy_single_repeat = 7 ,
saved_state_rep_slow_dot = 8 ,
saved_state_rep_fast_dot = 9 ,
saved_state_rep_char = 10 ,
saved_state_rep_short_set = 11 ,
saved_state_rep_long_set = 12 ,
saved_state_non_greedy_long_repeat = 13 ,
saved_state_count = 14
} ;

template < class Results >
struct recursion_info
{
typedef typename Results :: value_type value_type ;
typedef typename value_type :: iterator iterator ;
int idx ;
const re_syntax_base * preturn_address ;
Results results ;
repeater_count < iterator > * repeater_stack ;
} ;
#353
template < class BidiIterator , class Allocator , class traits >
class perl_matcher
{
public :
typedef typename traits :: char_type char_type ;
typedef perl_matcher < BidiIterator , Allocator , traits > self_type ;
typedef bool ( self_type :: * matcher_proc_type ) ( void ) ;
typedef std :: size_t traits_size_type ;
typedef typename is_byte < char_type > :: width_type width_type ;
typedef typename regex_iterator_traits < BidiIterator > :: difference_type difference_type ;
typedef match_results < BidiIterator , Allocator > results_type ;

perl_matcher ( BidiIterator first , BidiIterator end ,
match_results < BidiIterator , Allocator > & what ,
const basic_regex < char_type , traits > & e ,
match_flag_type f ,
BidiIterator l_base )
: m_result ( what ) , base ( first ) , last ( end ) ,
position ( first ) , backstop ( l_base ) , re ( e ) , traits_inst ( e . get_traits ( ) ) ,
m_independent ( false ) , next_count ( & rep_obj ) , rep_obj ( & next_count )
{
construct_init ( e , f ) ;
}

bool match ( ) ;
bool find ( ) ;

void setf ( match_flag_type f )
{ m_match_flags |= f ; }
void unsetf ( match_flag_type f )
{ m_match_flags &= ~ f ; }

private :
void construct_init ( const basic_regex < char_type , traits > & e , match_flag_type f ) ;

bool find_imp ( ) ;
bool match_imp ( ) ;




void estimate_max_state_count ( std :: random_access_iterator_tag * ) ;
void estimate_max_state_count ( void * ) ;
bool match_prefix ( ) ;
bool match_all_states ( ) ;


bool match_startmark ( ) ;
bool match_endmark ( ) ;
bool match_literal ( ) ;
bool match_start_line ( ) ;
bool match_end_line ( ) ;
bool match_wild ( ) ;
bool match_match ( ) ;
bool match_word_boundary ( ) ;
bool match_within_word ( ) ;
bool match_word_start ( ) ;
bool match_word_end ( ) ;
bool match_buffer_start ( ) ;
bool match_buffer_end ( ) ;
bool match_backref ( ) ;
bool match_long_set ( ) ;
bool match_set ( ) ;
bool match_jump ( ) ;
bool match_alt ( ) ;
bool match_rep ( ) ;
bool match_combining ( ) ;
bool match_soft_buffer_end ( ) ;
bool match_restart_continue ( ) ;
bool match_long_set_repeat ( ) ;
bool match_set_repeat ( ) ;
bool match_char_repeat ( ) ;
bool match_dot_repeat_fast ( ) ;
bool match_dot_repeat_slow ( ) ;
bool match_dot_repeat_dispatch ( )
{
return :: boost :: is_random_access_iterator < BidiIterator > :: value ? match_dot_repeat_fast ( ) : match_dot_repeat_slow
#429
( ) ;
}
bool match_backstep ( ) ;
bool match_assert_backref ( ) ;
bool match_toggle_case ( ) ;



bool match_recursion ( ) ;


bool find_restart_any ( ) ;
bool find_restart_word ( ) ;
bool find_restart_line ( ) ;
bool find_restart_buf ( ) ;
bool find_restart_lit ( ) ;

private :

match_results < BidiIterator , Allocator > & m_result ;

scoped_ptr < match_results < BidiIterator , Allocator > > m_temp_match ;

match_results < BidiIterator , Allocator > * m_presult ;

BidiIterator base ;

BidiIterator last ;

BidiIterator position ;

BidiIterator restart ;

BidiIterator search_base ;

BidiIterator backstop ;

const basic_regex < char_type , traits > & re ;

const :: boost :: regex_traits_wrapper < traits > & traits_inst ;

const re_syntax_base * pstate ;

match_flag_type m_match_flags ;

std :: ptrdiff_t state_count ;

std :: ptrdiff_t max_state_count ;

bool icase ;

bool m_has_partial_match ;

bool m_has_found_match ;

bool m_independent ;

repeater_count < BidiIterator > * next_count ;

repeater_count < BidiIterator > rep_obj ;

typename traits :: char_class_type m_word_mask ;

unsigned char match_any_mask ;

std :: vector < recursion_info < results_type > > recursion_stack ;





typedef bool ( self_type :: * unwind_proc_type ) ( bool ) ;

void extend_stack ( ) ;
bool unwind ( bool ) ;
bool unwind_end ( bool ) ;
bool unwind_paren ( bool ) ;
bool unwind_recursion_stopper ( bool ) ;
bool unwind_assertion ( bool ) ;
bool unwind_alt ( bool ) ;
bool unwind_repeater_counter ( bool ) ;
bool unwind_extra_block ( bool ) ;
bool unwind_greedy_single_repeat ( bool ) ;
bool unwind_slow_dot_repeat ( bool ) ;
bool unwind_fast_dot_repeat ( bool ) ;
bool unwind_char_repeat ( bool ) ;
bool unwind_short_set_repeat ( bool ) ;
bool unwind_long_set_repeat ( bool ) ;
bool unwind_non_greedy_repeat ( bool ) ;
bool unwind_recursion ( bool ) ;
bool unwind_recursion_pop ( bool ) ;
void destroy_single_repeat ( ) ;
void push_matched_paren ( int index , const sub_match < BidiIterator > & sub ) ;
void push_recursion_stopper ( ) ;
void push_assertion ( const re_syntax_base * ps , bool positive ) ;
void push_alt ( const re_syntax_base * ps ) ;
void push_repeater_count ( int i , repeater_count < BidiIterator > * * s ) ;
void push_single_repeat ( std :: size_t c , const re_repeat * r , BidiIterator last_position , int state_id ) ;
void push_non_greedy_repeat ( const re_syntax_base * ps ) ;
void push_recursion ( int idx , const re_syntax_base * p , results_type * presults ) ;
void push_recursion_pop ( ) ;


saved_state * m_stack_base ;

saved_state * m_backup_state ;


bool m_recursive_result ;

unsigned used_block_count ;




perl_matcher & operator = ( const perl_matcher & )
{
return * this ;
}
perl_matcher ( const perl_matcher & that )
: m_result ( that . m_result ) , re ( that . re ) , traits_inst ( that . traits_inst ) , rep_obj ( 0 ) { }
} ;





}
#569
}
#1 "./boost/regex/v4/perl_matcher_non_recursive.hpp"
#40
namespace boost {
namespace re_detail {

template < class T >
inline void inplace_destroy ( T * p )
{
( void ) p ;
p -> ~ T ( ) ;
}

struct saved_state
{
union {
unsigned int state_id ;

std :: size_t padding1 ;
std :: ptrdiff_t padding2 ;
void * padding3 ;
} ;
saved_state ( unsigned i ) : state_id ( i ) { }
} ;

template < class BidiIterator >
struct saved_matched_paren : public saved_state
{
int index ;
sub_match < BidiIterator > sub ;
saved_matched_paren ( int i , const sub_match < BidiIterator > & s ) : saved_state ( 1 ) , index ( i ) , sub ( s ) { } ;
#67

} ;

template < class BidiIterator >
struct saved_position : public saved_state
{
const re_syntax_base * pstate ;
BidiIterator position ;
saved_position ( const re_syntax_base * ps , BidiIterator pos , int i ) : saved_state ( i ) , pstate ( ps ) , position (
#75
pos ) { } ;
} ;

template < class BidiIterator >
struct saved_assertion : public saved_position < BidiIterator >
{
bool positive ;
saved_assertion ( bool p , const re_syntax_base * ps , BidiIterator pos )
: saved_position < BidiIterator > ( ps , pos , saved_type_assertion ) , positive ( p ) { } ;
} ;

template < class BidiIterator >
struct saved_repeater : public saved_state
{
repeater_count < BidiIterator > count ;
saved_repeater ( int i , repeater_count < BidiIterator > * * s , BidiIterator start )
: saved_state ( saved_state_repeater_count ) , count ( i , s , start ) { }
} ;

struct saved_extra_block : public saved_state
{
saved_state * base , * end ;
saved_extra_block ( saved_state * b , saved_state * e )
: saved_state ( saved_state_extra_block ) , base ( b ) , end ( e ) { }
} ;

struct save_state_init
{
saved_state * * stack ;
save_state_init ( saved_state * * base , saved_state * * end )
: stack ( base )
{
* base = static_cast < saved_state * > ( get_mem_block ( ) ) ;
* end = reinterpret_cast < saved_state * > ( reinterpret_cast < char * > ( * base ) + 4096 ) ;
-- ( * end ) ;
( void ) new ( * end ) saved_state ( 0 ) ;
( ( void ) 0 ) ;
}
~ save_state_init ( )
{
put_mem_block ( * stack ) ;
* stack = 0 ;
}
} ;

template < class BidiIterator >
struct saved_single_repeat : public saved_state
{
std :: size_t count ;
const re_repeat * rep ;
BidiIterator last_position ;
saved_single_repeat ( std :: size_t c , const re_repeat * r , BidiIterator lp , int arg_id )
: saved_state ( arg_id ) , count ( c ) , rep ( r ) , last_position ( lp ) { }
} ;

template < class Results >
struct saved_recursion : public saved_state
{
saved_recursion ( int idx , const re_syntax_base * p , Results * pr )
: saved_state ( 14 ) , recursion_id ( idx ) , preturn_address ( p ) , results ( * pr )
{ }
int recursion_id ;
const re_syntax_base * preturn_address ;
Results results ;
} ;

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_all_states ( )
{
static matcher_proc_type const s_match_vtable [ 30 ] =
{
( & perl_matcher < BidiIterator , Allocator , traits > :: match_startmark ) ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_endmark ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_literal ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_start_line ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_end_line ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_wild ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_match ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_word_boundary ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_within_word ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_word_start ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_word_end ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_buffer_start ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_buffer_end ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_backref ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_long_set ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_set ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_jump ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_alt ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_rep ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_combining ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_soft_buffer_end ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_restart_continue ,




& perl_matcher < BidiIterator , Allocator , traits > :: match_dot_repeat_dispatch ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_char_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_set_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_long_set_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_backstep ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_assert_backref ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_toggle_case ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_recursion ,
} ;

push_recursion_stopper ( ) ;
do {
while ( pstate )
{
matcher_proc_type proc = s_match_vtable [ pstate -> type ] ;
++ state_count ;
if ( ! ( this ->* proc ) ( ) )
{
if ( state_count > max_state_count )
raise_error ( traits_inst , regex_constants :: error_complexity ) ;
if ( ( m_match_flags & match_partial ) && ( position == last ) && ( position != search_base ) )
m_has_partial_match = true ;
bool successful_unwind = unwind ( false ) ;
if ( ( m_match_flags & match_partial ) && ( position == last ) && ( position != search_base ) )
m_has_partial_match = true ;
if ( false == successful_unwind )
return m_recursive_result ;
}
}
} while ( unwind ( true ) ) ;
return m_recursive_result ;
}

template < class BidiIterator , class Allocator , class traits >
void perl_matcher < BidiIterator , Allocator , traits > :: extend_stack ( )
{
if ( used_block_count )
{
-- used_block_count ;
saved_state * stack_base ;
saved_state * backup_state ;
stack_base = static_cast < saved_state * > ( get_mem_block ( ) ) ;
backup_state = reinterpret_cast < saved_state * > ( reinterpret_cast < char * > ( stack_base ) + 4096 ) ;
saved_extra_block * block = static_cast < saved_extra_block * > ( backup_state ) ;
-- block ;
( void ) new ( block ) saved_extra_block ( m_stack_base , m_backup_state ) ;
m_stack_base = stack_base ;
m_backup_state = block ;
}
else
raise_error ( traits_inst , regex_constants :: error_stack ) ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_matched_paren ( int index , const sub_match < BidiIterator
#226
> & sub )
{

saved_matched_paren < BidiIterator > * pmp = static_cast < saved_matched_paren < BidiIterator > * > ( m_backup_state ) ;
#229

-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_matched_paren < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_matched_paren < BidiIterator > ( index , sub ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_recursion_stopper ( )
{
saved_state * pmp = m_backup_state ;
-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = m_backup_state ;
-- pmp ;
}
( void ) new ( pmp ) saved_state ( saved_type_recurse ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_assertion ( const re_syntax_base * ps , bool positive
#257
)
{
saved_assertion < BidiIterator > * pmp = static_cast < saved_assertion < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_assertion < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_assertion < BidiIterator > ( positive , ps , position ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_alt ( const re_syntax_base * ps )
{
saved_position < BidiIterator > * pmp = static_cast < saved_position < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_position < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_position < BidiIterator > ( ps , position , saved_state_alt ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_non_greedy_repeat ( const re_syntax_base * ps )
{
saved_position < BidiIterator > * pmp = static_cast < saved_position < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_position < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_position < BidiIterator > ( ps , position , saved_state_non_greedy_long_repeat ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_repeater_count ( int i , repeater_count < BidiIterator
#302
> * * s )
{
saved_repeater < BidiIterator > * pmp = static_cast < saved_repeater < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_repeater < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_repeater < BidiIterator > ( i , s , position ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_single_repeat ( std :: size_t c , const re_repeat
#317
* r , BidiIterator last_position , int state_id )
{
saved_single_repeat < BidiIterator > * pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
#319

-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_single_repeat < BidiIterator > ( c , r , last_position , state_id ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: push_recursion ( int idx , const re_syntax_base * p , results_type
#332
* presults )
{
saved_recursion < results_type > * pmp = static_cast < saved_recursion < results_type > * > ( m_backup_state ) ;
-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_recursion < results_type > * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_recursion < results_type > ( idx , p , presults ) ;
m_backup_state = pmp ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_startmark ( )
{
int index = static_cast < const re_brace * > ( pstate ) -> index ;
icase = static_cast < const re_brace * > ( pstate ) -> icase ;
switch ( index )
{
case 0 :
pstate = pstate -> next . p ;
break ;
case - 1 :
case - 2 :
{

const re_syntax_base * next_pstate = static_cast < const re_jump * > ( pstate -> next . p ) -> alt . p -> next . p ;
pstate = pstate -> next . p -> next . p ;
push_assertion ( next_pstate , index == - 1 ) ;
break ;
}
case - 3 :
{

bool old_independent = m_independent ;
m_independent = true ;
const re_syntax_base * next_pstate = static_cast < const re_jump * > ( pstate -> next . p ) -> alt . p -> next . p ;
pstate = pstate -> next . p -> next . p ;
bool r = match_all_states ( ) ;
pstate = next_pstate ;
m_independent = old_independent ;
#402
return r ;
}
case - 4 :
{

const re_alt * alt = static_cast < const re_alt * > ( pstate -> next . p ) ;
( ( void ) 0 ) ;
pstate = alt -> next . p ;
if ( pstate -> type == syntax_element_assert_backref )
{
if ( ! match_assert_backref ( ) )
pstate = alt -> alt . p ;
break ;
}
else
{

( ( void ) 0 ) ;
bool negated = static_cast < const re_brace * > ( pstate ) -> index == - 2 ;
BidiIterator saved_position = position ;
const re_syntax_base * next_pstate = static_cast < const re_jump * > ( pstate -> next . p ) -> alt . p -> next . p ;
pstate = pstate -> next . p -> next . p ;
bool r = match_all_states ( ) ;
position = saved_position ;
if ( negated )
r = ! r ;
if ( r )
pstate = next_pstate ;
else
pstate = alt -> alt . p ;
break ;
}
}
case - 5 :
{
push_matched_paren ( 0 , ( * m_presult ) [ 0 ] ) ;
m_presult -> set_first ( position , 0 , true ) ;
pstate = pstate -> next . p ;
break ;
}
default :
{
( ( void ) 0 ) ;
if ( ( m_match_flags & match_nosubs ) == 0 )
{
push_matched_paren ( index , ( * m_presult ) [ index ] ) ;
m_presult -> set_first ( position , index ) ;
}
pstate = pstate -> next . p ;
break ;
}
}
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_alt ( )
{
bool take_first , take_second ;
const re_alt * jmp = static_cast < const re_alt * > ( pstate ) ;


if ( position == last )
{
take_first = jmp -> can_be_null & mask_take ;
take_second = jmp -> can_be_null & mask_skip ;
}
else
{
take_first = can_start ( * position , jmp -> _map , ( unsigned char ) mask_take ) ;
take_second = can_start ( * position , jmp -> _map , ( unsigned char ) mask_skip ) ;
}

if ( take_first )
{


if ( take_second )
{
push_alt ( jmp -> alt . p ) ;
}
pstate = pstate -> next . p ;
return true ;
}
if ( take_second )
{
pstate = jmp -> alt . p ;
return true ;
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_rep ( )
{
#504
const re_repeat * rep = static_cast < const re_repeat * > ( pstate ) ;


bool take_first , take_second ;
if ( position == last )
{
take_first = rep -> can_be_null & mask_take ;
take_second = rep -> can_be_null & mask_skip ;
}
else
{
take_first = can_start ( * position , rep -> _map , ( unsigned char ) mask_take ) ;
take_second = can_start ( * position , rep -> _map , ( unsigned char ) mask_skip ) ;
}

if ( ( m_backup_state -> state_id != saved_state_repeater_count )
|| ( static_cast < saved_repeater < BidiIterator > * > ( m_backup_state ) -> count . get_id ( ) != rep -> state_id )
|| ( next_count -> get_id ( ) != rep -> state_id ) )
{


push_repeater_count ( rep -> state_id , & next_count ) ;
}





next_count -> check_null_repeat ( position , rep -> max ) ;

if ( next_count -> get_count ( ) < rep -> min )
{

if ( take_first )
{

++ ( * next_count ) ;
pstate = rep -> next . p ;
return true ;
}
return false ;
}

bool greedy = ( rep -> greedy ) && ( ! ( m_match_flags & regex_constants :: match_any ) || m_independent ) ;
if ( greedy )
{

if ( ( next_count -> get_count ( ) < rep -> max ) && take_first )
{
if ( take_second )
{

push_alt ( rep -> alt . p ) ;
}

++ ( * next_count ) ;
pstate = rep -> next . p ;
return true ;
}
else if ( take_second )
{
pstate = rep -> alt . p ;
return true ;
}
return false ;
}
else
{

if ( take_second )
{
if ( ( next_count -> get_count ( ) < rep -> max ) && take_first )
{

push_non_greedy_repeat ( rep -> next . p ) ;
}
pstate = rep -> alt . p ;
return true ;
}
if ( ( next_count -> get_count ( ) < rep -> max ) && take_first )
{

++ ( * next_count ) ;
pstate = rep -> next . p ;
return true ;
}
}
return false ;
#598
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_dot_repeat_slow ( )
{
unsigned count = 0 ;
const re_repeat * rep = static_cast < const re_repeat * > ( pstate ) ;
re_syntax_base * psingle = rep -> next . p ;

while ( count < rep -> min )
{
pstate = psingle ;
if ( ! match_wild ( ) )
return false ;
++ count ;
}
bool greedy = ( rep -> greedy ) && ( ! ( m_match_flags & regex_constants :: match_any ) || m_independent ) ;
if ( greedy )
{

while ( count < rep -> max )
{
pstate = psingle ;
if ( ! match_wild ( ) )
break ;
++ count ;
}

if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;

if ( count - rep -> min )
push_single_repeat ( count , rep , position , saved_state_greedy_single_repeat ) ;

pstate = rep -> alt . p ;
return true ;
}
else
{

if ( count < rep -> max )
push_single_repeat ( count , rep , position , saved_state_rep_slow_dot ) ;
pstate = rep -> alt . p ;
return ( position == last ) ? ( rep -> can_be_null & mask_skip ) : can_start ( * position , rep -> _map , mask_skip ) ;
}
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_dot_repeat_fast ( )
{
if ( m_match_flags & match_not_dot_null )
return match_dot_repeat_slow ( ) ;
if ( ( static_cast < const re_dot * > ( pstate -> next . p ) -> mask & match_any_mask ) == 0 )
return match_dot_repeat_slow ( ) ;

const re_repeat * rep = static_cast < const re_repeat * > ( pstate ) ;
bool greedy = ( rep -> greedy ) && ( ! ( m_match_flags & regex_constants :: match_any ) || m_independent ) ;
unsigned count = static_cast < unsigned > ( ( std :: min ) ( static_cast < unsigned > ( :: boost :: re_detail :: distance
#655
( position , last ) ) , static_cast < unsigned > ( greedy ? rep -> max : rep -> min ) ) ) ;
if ( rep -> min > count )
{
position = last ;
return false ;
}
std :: advance ( position , count ) ;

if ( greedy )
{
if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;

if ( count - rep -> min )
push_single_repeat ( count , rep , position , saved_state_greedy_single_repeat ) ;

pstate = rep -> alt . p ;
return true ;
}
else
{

if ( count < rep -> max )
push_single_repeat ( count , rep , position , saved_state_rep_fast_dot ) ;
pstate = rep -> alt . p ;
return ( position == last ) ? ( rep -> can_be_null & mask_skip ) : can_start ( * position , rep -> _map , mask_skip ) ;
}
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_char_repeat ( )
{
#694
const re_repeat * rep = static_cast < const re_repeat * > ( pstate ) ;
( ( void ) 0 ) ;
const char_type what = * reinterpret_cast < const char_type * > ( static_cast < const re_literal * > ( rep -> next . p )
#696
+ 1 ) ;
std :: size_t count = 0 ;



bool greedy = ( rep -> greedy ) && ( ! ( m_match_flags & regex_constants :: match_any ) || m_independent ) ;
std :: size_t desired = greedy ? rep -> max : rep -> min ;
if ( :: boost :: is_random_access_iterator < BidiIterator > :: value )
{
BidiIterator end = position ;
std :: advance ( end , ( std :: min ) ( ( std :: size_t ) :: boost :: re_detail :: distance ( position , last ) , desired
#706
) ) ;
BidiIterator origin ( position ) ;
while ( ( position != end ) && ( traits_inst . translate ( * position , icase ) == what ) )
{
++ position ;
}
count = ( unsigned ) :: boost :: re_detail :: distance ( origin , position ) ;
}
else
{
while ( ( count < desired ) && ( position != last ) && ( traits_inst . translate ( * position , icase ) == what ) )
{
++ position ;
++ count ;
}
}

if ( count < rep -> min )
return false ;

if ( greedy )
{
if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;

if ( count - rep -> min )
push_single_repeat ( count , rep , position , saved_state_greedy_single_repeat ) ;

pstate = rep -> alt . p ;
return true ;
}
else
{

if ( count < rep -> max )
push_single_repeat ( count , rep , position , saved_state_rep_char ) ;
pstate = rep -> alt . p ;
return ( position == last ) ? ( rep -> can_be_null & mask_skip ) : can_start ( * position , rep -> _map , mask_skip ) ;
}
#751
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_set_repeat ( )
{
#763
const re_repeat * rep = static_cast < const re_repeat * > ( pstate ) ;
const unsigned char * map = static_cast < const re_set * > ( rep -> next . p ) -> _map ;
std :: size_t count = 0 ;



bool greedy = ( rep -> greedy ) && ( ! ( m_match_flags & regex_constants :: match_any ) || m_independent ) ;
std :: size_t desired = greedy ? rep -> max : rep -> min ;
if ( :: boost :: is_random_access_iterator < BidiIterator > :: value )
{
BidiIterator end = position ;
std :: advance ( end , ( std :: min ) ( ( std :: size_t ) :: boost :: re_detail :: distance ( position , last ) , desired
#774
) ) ;
BidiIterator origin ( position ) ;
while ( ( position != end ) && map [ static_cast < unsigned char > ( traits_inst . translate ( * position , icase ) ) ] )
#776

{
++ position ;
}
count = ( unsigned ) :: boost :: re_detail :: distance ( origin , position ) ;
}
else
{
while ( ( count < desired ) && ( position != last ) && map [ static_cast < unsigned char > ( traits_inst . translate ( *
#784
position , icase ) ) ] )
{
++ position ;
++ count ;
}
}

if ( count < rep -> min )
return false ;

if ( greedy )
{
if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;

if ( count - rep -> min )
push_single_repeat ( count , rep , position , saved_state_greedy_single_repeat ) ;

pstate = rep -> alt . p ;
return true ;
}
else
{

if ( count < rep -> max )
push_single_repeat ( count , rep , position , saved_state_rep_short_set ) ;
pstate = rep -> alt . p ;
return ( position == last ) ? ( rep -> can_be_null & mask_skip ) : can_start ( * position , rep -> _map , mask_skip ) ;
}
#819
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_long_set_repeat ( )
{
#831
typedef typename traits :: char_class_type m_type ;
const re_repeat * rep = static_cast < const re_repeat * > ( pstate ) ;
const re_set_long < m_type > * set = static_cast < const re_set_long < m_type > * > ( pstate -> next . p ) ;
std :: size_t count = 0 ;



bool greedy = ( rep -> greedy ) && ( ! ( m_match_flags & regex_constants :: match_any ) || m_independent ) ;
std :: size_t desired = greedy ? rep -> max : rep -> min ;
if ( :: boost :: is_random_access_iterator < BidiIterator > :: value )
{
BidiIterator end = position ;
std :: advance ( end , ( std :: min ) ( ( std :: size_t ) :: boost :: re_detail :: distance ( position , last ) , desired
#843
) ) ;
BidiIterator origin ( position ) ;
while ( ( position != end ) && ( position != re_is_set_member ( position , last , set , re . get_data ( ) , icase ) ) )
{
++ position ;
}
count = ( unsigned ) :: boost :: re_detail :: distance ( origin , position ) ;
}
else
{
while ( ( count < desired ) && ( position != last ) && ( position != re_is_set_member ( position , last , set , re . get_data
#853
( ) , icase ) ) )
{
++ position ;
++ count ;
}
}

if ( count < rep -> min )
return false ;

if ( greedy )
{
if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;

if ( count - rep -> min )
push_single_repeat ( count , rep , position , saved_state_greedy_single_repeat ) ;

pstate = rep -> alt . p ;
return true ;
}
else
{

if ( count < rep -> max )
push_single_repeat ( count , rep , position , saved_state_rep_long_set ) ;
pstate = rep -> alt . p ;
return ( position == last ) ? ( rep -> can_be_null & mask_skip ) : can_start ( * position , rep -> _map , mask_skip ) ;
}
#888
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_recursion ( )
{
( ( void ) 0 ) ;



push_recursion_pop ( ) ;



if ( recursion_stack . capacity ( ) == 0 )
{
recursion_stack . reserve ( 50 ) ;
}
recursion_stack . push_back ( recursion_info < results_type > ( ) ) ;
recursion_stack . back ( ) . preturn_address = pstate -> next . p ;
recursion_stack . back ( ) . results = * m_presult ;
if ( static_cast < const re_recurse * > ( pstate ) -> state_id > 0 )
{
push_repeater_count ( static_cast < const re_recurse * > ( pstate ) -> state_id , & next_count ) ;
}
pstate = static_cast < const re_jump * > ( pstate ) -> alt . p ;
recursion_stack . back ( ) . idx = static_cast < const re_brace * > ( pstate ) -> index ;

return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_endmark ( )
{
int index = static_cast < const re_brace * > ( pstate ) -> index ;
icase = static_cast < const re_brace * > ( pstate ) -> icase ;
if ( index > 0 )
{
if ( ( m_match_flags & match_nosubs ) == 0 )
{
m_presult -> set_second ( position , index ) ;
}
if ( ! recursion_stack . empty ( ) )
{
if ( index == recursion_stack . back ( ) . idx )
{
pstate = recursion_stack . back ( ) . preturn_address ;
* m_presult = recursion_stack . back ( ) . results ;
push_recursion ( recursion_stack . back ( ) . idx , recursion_stack . back ( ) . preturn_address , & recursion_stack . back
#935
( ) . results ) ;
recursion_stack . pop_back ( ) ;
}
}
}
else if ( ( index < 0 ) && ( index != - 4 ) )
{

pstate = 0 ;
return true ;
}
pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_match ( )
{
if ( ! recursion_stack . empty ( ) )
{
( ( void ) 0 ) ;
pstate = recursion_stack . back ( ) . preturn_address ;
* m_presult = recursion_stack . back ( ) . results ;
push_recursion ( recursion_stack . back ( ) . idx , recursion_stack . back ( ) . preturn_address , & recursion_stack . back
#958
( ) . results ) ;
recursion_stack . pop_back ( ) ;
return true ;
}
if ( ( m_match_flags & match_not_null ) && ( position == ( * m_presult ) [ 0 ] . first ) )
return false ;
if ( ( m_match_flags & match_all ) && ( position != last ) )
return false ;
if ( ( m_match_flags & regex_constants :: match_not_initial_null ) && ( position == search_base ) )
return false ;
m_presult -> set_second ( position ) ;
pstate = 0 ;
m_has_found_match = true ;
if ( ( m_match_flags & match_posix ) == match_posix )
{
m_result . maybe_assign ( * m_presult ) ;
if ( ( m_match_flags & match_any ) == 0 )
return false ;
}
#985
return true ;
}
#995
template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind ( bool have_match )
{
static unwind_proc_type const s_unwind_table [ 18 ] =
{
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_end ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_paren ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_recursion_stopper ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_assertion ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_alt ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_repeater_counter ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_extra_block ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_greedy_single_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_slow_dot_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_fast_dot_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_char_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_short_set_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_long_set_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_non_greedy_repeat ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_recursion ,
& perl_matcher < BidiIterator , Allocator , traits > :: unwind_recursion_pop ,
} ;

m_recursive_result = have_match ;
unwind_proc_type unwinder ;
bool cont ;



do
{
unwinder = s_unwind_table [ m_backup_state -> state_id ] ;
cont = ( this ->* unwinder ) ( m_recursive_result ) ;
} while ( cont ) ;



return pstate ? true : false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_end ( bool )
{
pstate = 0 ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_paren ( bool have_match )
{
saved_matched_paren < BidiIterator > * pmp = static_cast < saved_matched_paren < BidiIterator > * > ( m_backup_state ) ;
#1045


if ( have_match == false )
{
m_presult -> set_first ( pmp -> sub . first , pmp -> index , pmp -> index == 0 ) ;
m_presult -> set_second ( pmp -> sub . second , pmp -> index , pmp -> sub . matched , pmp -> index == 0 ) ;
}
#1060
m_backup_state = pmp + 1 ;
boost :: re_detail :: inplace_destroy ( pmp ) ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_recursion_stopper ( bool )
{
boost :: re_detail :: inplace_destroy ( m_backup_state ++ ) ;
pstate = 0 ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_assertion ( bool r )
{
saved_assertion < BidiIterator > * pmp = static_cast < saved_assertion < BidiIterator > * > ( m_backup_state ) ;
pstate = pmp -> pstate ;
position = pmp -> position ;
bool result = ( r == pmp -> positive ) ;
m_recursive_result = pmp -> positive ? r : ! r ;
boost :: re_detail :: inplace_destroy ( pmp ++ ) ;
m_backup_state = pmp ;
return ! result ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_alt ( bool r )
{
saved_position < BidiIterator > * pmp = static_cast < saved_position < BidiIterator > * > ( m_backup_state ) ;
if ( ! r )
{
pstate = pmp -> pstate ;
position = pmp -> position ;
}
boost :: re_detail :: inplace_destroy ( pmp ++ ) ;
m_backup_state = pmp ;
return r ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_repeater_counter ( bool )
{
saved_repeater < BidiIterator > * pmp = static_cast < saved_repeater < BidiIterator > * > ( m_backup_state ) ;
boost :: re_detail :: inplace_destroy ( pmp ++ ) ;
m_backup_state = pmp ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_extra_block ( bool )
{
saved_extra_block * pmp = static_cast < saved_extra_block * > ( m_backup_state ) ;
void * condemmed = m_stack_base ;
m_stack_base = pmp -> base ;
m_backup_state = pmp -> end ;
boost :: re_detail :: inplace_destroy ( pmp ) ;
put_mem_block ( condemmed ) ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: destroy_single_repeat ( )
{
saved_single_repeat < BidiIterator > * p = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
boost :: re_detail :: inplace_destroy ( p ++ ) ;
m_backup_state = p ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_greedy_single_repeat ( bool r )
{
saved_single_repeat < BidiIterator > * pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
#1132



if ( r )
{
destroy_single_repeat ( ) ;
return true ;
}

const re_repeat * rep = pmp -> rep ;
std :: size_t count = pmp -> count ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;

count -= rep -> min ;

if ( ( m_match_flags & match_partial ) && ( position == last ) )
m_has_partial_match = true ;

( ( void ) 0 ) ;
position = pmp -> last_position ;


do
{
-- position ;
-- count ;
++ state_count ;
} while ( count && ! can_start ( * position , rep -> _map , mask_skip ) ) ;


if ( count == 0 )
{
destroy_single_repeat ( ) ;
if ( ! can_start ( * position , rep -> _map , mask_skip ) )
return true ;
}
else
{
pmp -> count = count + rep -> min ;
pmp -> last_position = position ;
}
pstate = rep -> alt . p ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_slow_dot_repeat ( bool r )
{
saved_single_repeat < BidiIterator > * pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
#1181



if ( r )
{
destroy_single_repeat ( ) ;
return true ;
}

const re_repeat * rep = pmp -> rep ;
std :: size_t count = pmp -> count ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;

( ( void ) 0 ) ;
pstate = rep -> next . p ;
position = pmp -> last_position ;

if ( position != last )
{

do
{
if ( ! match_wild ( ) )
{

destroy_single_repeat ( ) ;
return true ;
}
++ count ;
++ state_count ;
pstate = rep -> next . p ;
} while ( ( count < rep -> max ) && ( position != last ) && ! can_start ( * position , rep -> _map , mask_skip ) ) ;
}
if ( position == last )
{

destroy_single_repeat ( ) ;
if ( ( m_match_flags & match_partial ) && ( position == last ) && ( position != search_base ) )
m_has_partial_match = true ;
if ( 0 == ( rep -> can_be_null & mask_skip ) )
return true ;
}
else if ( count == rep -> max )
{

destroy_single_repeat ( ) ;
if ( ! can_start ( * position , rep -> _map , mask_skip ) )
return true ;
}
else
{
pmp -> count = count ;
pmp -> last_position = position ;
}
pstate = rep -> alt . p ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_fast_dot_repeat ( bool r )
{
saved_single_repeat < BidiIterator > * pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
#1245



if ( r )
{
destroy_single_repeat ( ) ;
return true ;
}

const re_repeat * rep = pmp -> rep ;
std :: size_t count = pmp -> count ;

( ( void ) 0 ) ;
position = pmp -> last_position ;
if ( position != last )
{


do
{
++ position ;
++ count ;
++ state_count ;
} while ( ( count < rep -> max ) && ( position != last ) && ! can_start ( * position , rep -> _map , mask_skip ) ) ;
}


if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;
if ( position == last )
{

destroy_single_repeat ( ) ;
if ( ( m_match_flags & match_partial ) && ( position == last ) && ( position != search_base ) )
m_has_partial_match = true ;
if ( 0 == ( rep -> can_be_null & mask_skip ) )
return true ;
}
else if ( count == rep -> max )
{

destroy_single_repeat ( ) ;
if ( ! can_start ( * position , rep -> _map , mask_skip ) )
return true ;
}
else
{
pmp -> count = count ;
pmp -> last_position = position ;
}
pstate = rep -> alt . p ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_char_repeat ( bool r )
{
saved_single_repeat < BidiIterator > * pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
#1302



if ( r )
{
destroy_single_repeat ( ) ;
return true ;
}

const re_repeat * rep = pmp -> rep ;
std :: size_t count = pmp -> count ;
pstate = rep -> next . p ;
const char_type what = * reinterpret_cast < const char_type * > ( static_cast < const re_literal * > ( pstate ) + 1 ) ;
position = pmp -> last_position ;

( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;

if ( position != last )
{

do
{
if ( traits_inst . translate ( * position , icase ) != what )
{

destroy_single_repeat ( ) ;
return true ;
}
++ count ;
++ position ;
++ state_count ;
pstate = rep -> next . p ;
} while ( ( count < rep -> max ) && ( position != last ) && ! can_start ( * position , rep -> _map , mask_skip ) ) ;
}

if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;
if ( position == last )
{

destroy_single_repeat ( ) ;
if ( ( m_match_flags & match_partial ) && ( position == last ) && ( position != search_base ) )
m_has_partial_match = true ;
if ( 0 == ( rep -> can_be_null & mask_skip ) )
return true ;
}
else if ( count == rep -> max )
{

destroy_single_repeat ( ) ;
if ( ! can_start ( * position , rep -> _map , mask_skip ) )
return true ;
}
else
{
pmp -> count = count ;
pmp -> last_position = position ;
}
pstate = rep -> alt . p ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_short_set_repeat ( bool r )
{
saved_single_repeat < BidiIterator > * pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
#1371



if ( r )
{
destroy_single_repeat ( ) ;
return true ;
}

const re_repeat * rep = pmp -> rep ;
std :: size_t count = pmp -> count ;
pstate = rep -> next . p ;
const unsigned char * map = static_cast < const re_set * > ( rep -> next . p ) -> _map ;
position = pmp -> last_position ;

( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;

if ( position != last )
{

do
{
if ( ! map [ static_cast < unsigned char > ( traits_inst . translate ( * position , icase ) ) ] )
{

destroy_single_repeat ( ) ;
return true ;
}
++ count ;
++ position ;
++ state_count ;
pstate = rep -> next . p ;
} while ( ( count < rep -> max ) && ( position != last ) && ! can_start ( * position , rep -> _map , mask_skip ) ) ;
}

if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;
if ( position == last )
{

destroy_single_repeat ( ) ;
if ( ( m_match_flags & match_partial ) && ( position == last ) && ( position != search_base ) )
m_has_partial_match = true ;
if ( 0 == ( rep -> can_be_null & mask_skip ) )
return true ;
}
else if ( count == rep -> max )
{

destroy_single_repeat ( ) ;
if ( ! can_start ( * position , rep -> _map , mask_skip ) )
return true ;
}
else
{
pmp -> count = count ;
pmp -> last_position = position ;
}
pstate = rep -> alt . p ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_long_set_repeat ( bool r )
{
typedef typename traits :: char_class_type m_type ;
saved_single_repeat < BidiIterator > * pmp = static_cast < saved_single_repeat < BidiIterator > * > ( m_backup_state ) ;
#1441



if ( r )
{
destroy_single_repeat ( ) ;
return true ;
}

const re_repeat * rep = pmp -> rep ;
std :: size_t count = pmp -> count ;
pstate = rep -> next . p ;
const re_set_long < m_type > * set = static_cast < const re_set_long < m_type > * > ( pstate ) ;
position = pmp -> last_position ;

( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;
( ( void ) 0 ) ;

if ( position != last )
{

do
{
if ( position == re_is_set_member ( position , last , set , re . get_data ( ) , icase ) )
{

destroy_single_repeat ( ) ;
return true ;
}
++ position ;
++ count ;
++ state_count ;
pstate = rep -> next . p ;
} while ( ( count < rep -> max ) && ( position != last ) && ! can_start ( * position , rep -> _map , mask_skip ) ) ;
}

if ( ( rep -> leading ) && ( count < rep -> max ) )
restart = position ;
if ( position == last )
{

destroy_single_repeat ( ) ;
if ( ( m_match_flags & match_partial ) && ( position == last ) && ( position != search_base ) )
m_has_partial_match = true ;
if ( 0 == ( rep -> can_be_null & mask_skip ) )
return true ;
}
else if ( count == rep -> max )
{

destroy_single_repeat ( ) ;
if ( ! can_start ( * position , rep -> _map , mask_skip ) )
return true ;
}
else
{
pmp -> count = count ;
pmp -> last_position = position ;
}
pstate = rep -> alt . p ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_non_greedy_repeat ( bool r )
{
saved_position < BidiIterator > * pmp = static_cast < saved_position < BidiIterator > * > ( m_backup_state ) ;
if ( ! r )
{
position = pmp -> position ;
pstate = pmp -> pstate ;
++ ( * next_count ) ;
}
boost :: re_detail :: inplace_destroy ( pmp ++ ) ;
m_backup_state = pmp ;
return r ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_recursion ( bool r )
{
saved_recursion < results_type > * pmp = static_cast < saved_recursion < results_type > * > ( m_backup_state ) ;
if ( ! r )
{
recursion_stack . push_back ( recursion_info < results_type > ( ) ) ;
recursion_stack . back ( ) . idx = pmp -> recursion_id ;
recursion_stack . back ( ) . preturn_address = pmp -> preturn_address ;
recursion_stack . back ( ) . results = pmp -> results ;
}
boost :: re_detail :: inplace_destroy ( pmp ++ ) ;
m_backup_state = pmp ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: unwind_recursion_pop ( bool r )
{
saved_state * pmp = static_cast < saved_state * > ( m_backup_state ) ;
if ( ! r )
{
recursion_stack . pop_back ( ) ;
}
boost :: re_detail :: inplace_destroy ( pmp ++ ) ;
m_backup_state = pmp ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
void perl_matcher < BidiIterator , Allocator , traits > :: push_recursion_pop ( )
{
saved_state * pmp = static_cast < saved_state * > ( m_backup_state ) ;
-- pmp ;
if ( pmp < m_stack_base )
{
extend_stack ( ) ;
pmp = static_cast < saved_state * > ( m_backup_state ) ;
-- pmp ;
}
( void ) new ( pmp ) saved_state ( 15 ) ;
m_backup_state = pmp ;
}
#1622
}
}
#1 "./boost/regex/v4/perl_matcher_common.hpp"
#42
namespace boost {
namespace re_detail {

template < class BidiIterator , class Allocator , class traits >
void perl_matcher < BidiIterator , Allocator , traits > :: construct_init ( const basic_regex < char_type , traits > & e
#46
, match_flag_type f )
{
typedef typename regex_iterator_traits < BidiIterator > :: iterator_category category ;
typedef typename basic_regex < char_type , traits > :: flag_type expression_flag_type ;

if ( e . empty ( ) )
{

std :: invalid_argument ex ( "Invalid regular expression object" ) ;
boost :: throw_exception ( ex ) ;
}
pstate = 0 ;
m_match_flags = f ;
estimate_max_state_count ( static_cast < category * > ( 0 ) ) ;
expression_flag_type re_f = re . flags ( ) ;
icase = re_f & regex_constants :: icase ;
if ( ! ( m_match_flags & ( match_perl | match_posix ) ) )
{
if ( ( re_f & ( regbase :: main_option_type | regbase :: no_perl_ex ) ) == 0 )
m_match_flags |= match_perl ;
else if ( ( re_f & ( regbase :: main_option_type | regbase :: emacs_ex ) ) == ( regbase :: basic_syntax_group | regbase ::
#66
emacs_ex ) )
m_match_flags |= match_perl ;
else if ( ( re_f & ( regbase :: main_option_type | regbase :: literal ) ) == ( regbase :: literal ) )
m_match_flags |= match_perl ;
else
m_match_flags |= match_posix ;
}
if ( m_match_flags & match_posix )
{
m_temp_match . reset ( new match_results < BidiIterator , Allocator > ( ) ) ;
m_presult = m_temp_match . get ( ) ;
}
else
m_presult = & m_result ;

m_stack_base = 0 ;
m_backup_state = 0 ;


m_word_mask = re . get_data ( ) . m_word_mask ;

match_any_mask = static_cast < unsigned char > ( ( f & match_not_dot_newline ) ? re_detail :: test_not_newline : re_detail
#87
:: test_newline ) ;
}

template < class BidiIterator , class Allocator , class traits >
void perl_matcher < BidiIterator , Allocator , traits > :: estimate_max_state_count ( std :: random_access_iterator_tag *
#91
)
{
#103
static const std :: ptrdiff_t k = 100000 ;
std :: ptrdiff_t dist = boost :: re_detail :: distance ( base , last ) ;
if ( dist == 0 )
dist = 1 ;
std :: ptrdiff_t states = re . size ( ) ;
if ( states == 0 )
states = 1 ;
states *= states ;
if ( ( std :: numeric_limits < std :: ptrdiff_t > :: max ) ( ) / dist < states )
{
max_state_count = ( std :: min ) ( ( std :: ptrdiff_t ) 100000000 , ( std :: numeric_limits < std :: ptrdiff_t > :: max )
#113
( ) - 2 ) ;
return ;
}
states *= dist ;
if ( ( std :: numeric_limits < std :: ptrdiff_t > :: max ) ( ) - k < states )
{
max_state_count = ( std :: min ) ( ( std :: ptrdiff_t ) 100000000 , ( std :: numeric_limits < std :: ptrdiff_t > :: max )
#119
( ) - 2 ) ;
return ;
}
states += k ;

max_state_count = states ;




states = dist ;
if ( ( std :: numeric_limits < std :: ptrdiff_t > :: max ) ( ) / dist < states )
{
max_state_count = ( std :: min ) ( ( std :: ptrdiff_t ) 100000000 , ( std :: numeric_limits < std :: ptrdiff_t > :: max )
#132
( ) - 2 ) ;
return ;
}
states *= dist ;
if ( ( std :: numeric_limits < std :: ptrdiff_t > :: max ) ( ) - k < states )
{
max_state_count = ( std :: min ) ( ( std :: ptrdiff_t ) 100000000 , ( std :: numeric_limits < std :: ptrdiff_t > :: max )
#138
( ) - 2 ) ;
return ;
}
states += k ;




if ( states > 100000000 )
states = 100000000 ;




if ( states > max_state_count )
max_state_count = states ;
}

template < class BidiIterator , class Allocator , class traits >
inline void perl_matcher < BidiIterator , Allocator , traits > :: estimate_max_state_count ( void * )
{

max_state_count = 100000000 ;
}
#176
template < class BidiIterator , class Allocator , class traits >
inline bool perl_matcher < BidiIterator , Allocator , traits > :: match ( )
{



return match_imp ( ) ;

}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_imp ( )
{


save_state_init init ( & m_stack_base , & m_backup_state ) ;
used_block_count = 1024 ;

try {




position = base ;
search_base = base ;
state_count = 0 ;
m_match_flags |= regex_constants :: match_all ;
m_presult -> set_size ( ( m_match_flags & match_nosubs ) ? 1 : re . mark_count ( ) , search_base , last ) ;
m_presult -> set_base ( base ) ;
m_presult -> set_named_subs ( this -> re . get_named_subs ( ) ) ;
if ( m_match_flags & match_posix )
m_result = * m_presult ;
verify_options ( re . flags ( ) , m_match_flags ) ;
if ( 0 == match_prefix ( ) )
return false ;
return ( m_result [ 0 ] . second == last ) && ( m_result [ 0 ] . first == base ) ;


}
catch ( ... )
{



while ( unwind ( true ) ) { }
throw ;
}

}

template < class BidiIterator , class Allocator , class traits >
inline bool perl_matcher < BidiIterator , Allocator , traits > :: find ( )
{



return find_imp ( ) ;

}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: find_imp ( )
{
static matcher_proc_type const s_find_vtable [ 7 ] =
{
& perl_matcher < BidiIterator , Allocator , traits > :: find_restart_any ,
& perl_matcher < BidiIterator , Allocator , traits > :: find_restart_word ,
& perl_matcher < BidiIterator , Allocator , traits > :: find_restart_line ,
& perl_matcher < BidiIterator , Allocator , traits > :: find_restart_buf ,
& perl_matcher < BidiIterator , Allocator , traits > :: match_prefix ,
& perl_matcher < BidiIterator , Allocator , traits > :: find_restart_lit ,
& perl_matcher < BidiIterator , Allocator , traits > :: find_restart_lit ,
} ;



save_state_init init ( & m_stack_base , & m_backup_state ) ;
used_block_count = 1024 ;

try {



state_count = 0 ;
if ( ( m_match_flags & regex_constants :: match_init ) == 0 )
{

search_base = position = base ;
pstate = re . get_first_state ( ) ;
m_presult -> set_size ( ( m_match_flags & match_nosubs ) ? 1 : re . mark_count ( ) , base , last ) ;
m_presult -> set_base ( base ) ;
m_presult -> set_named_subs ( this -> re . get_named_subs ( ) ) ;
m_match_flags |= regex_constants :: match_init ;
}
else
{

search_base = position = m_result [ 0 ] . second ;


if ( ( ( m_match_flags & match_not_null ) == 0 ) && ( m_result . length ( ) == 0 ) )
{
if ( position == last )
return false ;
else
++ position ;
}

m_presult -> set_size ( ( m_match_flags & match_nosubs ) ? 1 : re . mark_count ( ) , search_base , last ) ;


}
if ( m_match_flags & match_posix )
{
m_result . set_size ( re . mark_count ( ) , base , last ) ;
m_result . set_base ( base ) ;
}

verify_options ( re . flags ( ) , m_match_flags ) ;

unsigned type = ( m_match_flags & match_continuous ) ?
static_cast < unsigned int > ( regbase :: restart_continue )
: static_cast < unsigned int > ( re . get_restart_type ( ) ) ;


matcher_proc_type proc = s_find_vtable [ type ] ;
return ( this ->* proc ) ( ) ;


}
catch ( ... )
{



while ( unwind ( true ) ) { }
throw ;
}

}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_prefix ( )
{
m_has_partial_match = false ;
m_has_found_match = false ;
pstate = re . get_first_state ( ) ;
m_presult -> set_first ( position ) ;
restart = position ;
match_all_states ( ) ;
if ( ! m_has_found_match && m_has_partial_match && ( m_match_flags & match_partial ) )
{
m_has_found_match = true ;
m_presult -> set_second ( last , 0 , false ) ;
position = last ;
if ( ( m_match_flags & match_posix ) == match_posix )
{
m_result . maybe_assign ( * m_presult ) ;
}
}
#349
if ( ! m_has_found_match )
position = restart ;
return m_has_found_match ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_literal ( )
{
unsigned int len = static_cast < const re_literal * > ( pstate ) -> length ;
const char_type * what = reinterpret_cast < const char_type * > ( static_cast < const re_literal * > ( pstate ) + 1 ) ;



for ( unsigned int i = 0 ; i < len ; ++ i , ++ position )
{
if ( ( position == last ) || ( traits_inst . translate ( * position , icase ) != what [ i ] ) )
return false ;
}
pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_start_line ( )
{
if ( position == backstop )
{
if ( ( m_match_flags & match_prev_avail ) == 0 )
{
if ( ( m_match_flags & match_not_bol ) == 0 )
{
pstate = pstate -> next . p ;
return true ;
}
return false ;
}
}
else if ( m_match_flags & match_single_line )
return false ;


BidiIterator t ( position ) ;
-- t ;
if ( position != last )
{
if ( is_separator ( * t ) && ! ( ( * t == static_cast < char_type > ( '\r' ) ) && ( * position == static_cast < char_type
#394
> ( '\n' ) ) ) )
{
pstate = pstate -> next . p ;
return true ;
}
}
else if ( is_separator ( * t ) )
{
pstate = pstate -> next . p ;
return true ;
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_end_line ( )
{
if ( position != last )
{
if ( m_match_flags & match_single_line )
return false ;

if ( is_separator ( * position ) )
{
if ( ( position != backstop ) || ( m_match_flags & match_prev_avail ) )
{

BidiIterator t ( position ) ;
-- t ;
if ( ( * t == static_cast < char_type > ( '\r' ) ) && ( * position == static_cast < char_type > ( '\n' ) ) )
{
return false ;
}
}
pstate = pstate -> next . p ;
return true ;
}
}
else if ( ( m_match_flags & match_not_eol ) == 0 )
{
pstate = pstate -> next . p ;
return true ;
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_wild ( )
{
if ( position == last )
return false ;
if ( is_separator ( * position ) && ( ( match_any_mask & static_cast < const re_dot * > ( pstate ) -> mask ) == 0 ) )
return false ;
if ( ( * position == char_type ( 0 ) ) && ( m_match_flags & match_not_dot_null ) )
return false ;
pstate = pstate -> next . p ;
++ position ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_word_boundary ( )
{
bool b ;
if ( position != last )
{




b = traits_inst . isctype ( * position , m_word_mask ) ;

}
else
{
b = ( m_match_flags & match_not_eow ) ? true : false ;
}
if ( ( position == backstop ) && ( ( m_match_flags & match_prev_avail ) == 0 ) )
{
if ( m_match_flags & match_not_bow )
b ^= true ;
else
b ^= false ;
}
else
{
-- position ;
b ^= traits_inst . isctype ( * position , m_word_mask ) ;
++ position ;
}
if ( b )
{
pstate = pstate -> next . p ;
return true ;
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_within_word ( )
{
if ( position == last )
return false ;

bool prev = traits_inst . isctype ( * position , m_word_mask ) ;
{
bool b ;
if ( ( position == backstop ) && ( ( m_match_flags & match_prev_avail ) == 0 ) )
return false ;
else
{
-- position ;
b = traits_inst . isctype ( * position , m_word_mask ) ;
++ position ;
}
if ( b == prev )
{
pstate = pstate -> next . p ;
return true ;
}
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_word_start ( )
{
if ( position == last )
return false ;
if ( ! traits_inst . isctype ( * position , m_word_mask ) )
return false ;
if ( ( position == backstop ) && ( ( m_match_flags & match_prev_avail ) == 0 ) )
{
if ( m_match_flags & match_not_bow )
return false ;
}
else
{

BidiIterator t ( position ) ;
-- t ;
if ( traits_inst . isctype ( * t , m_word_mask ) )
return false ;
}

pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_word_end ( )
{
if ( ( position == backstop ) && ( ( m_match_flags & match_prev_avail ) == 0 ) )
return false ;
BidiIterator t ( position ) ;
-- t ;
if ( traits_inst . isctype ( * t , m_word_mask ) == false )
return false ;

if ( position == last )
{
if ( m_match_flags & match_not_eow )
return false ;
}
else
{

if ( traits_inst . isctype ( * position , m_word_mask ) )
return false ;
}
pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_buffer_start ( )
{
if ( ( position != backstop ) || ( m_match_flags & match_not_bob ) )
return false ;

pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_buffer_end ( )
{
if ( ( position != last ) || ( m_match_flags & match_not_eob ) )
return false ;

pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_backref ( )
{
#597
int index = static_cast < const re_brace * > ( pstate ) -> index ;
if ( index >= 10000 )
{
named_subexpressions :: range_type r = re . get_data ( ) . equal_range ( index ) ;
( ( void ) 0 ) ;
do
{
index = r . first -> index ;
++ r . first ;
} while ( ( r . first != r . second ) && ( ( * m_presult ) [ index ] . matched != true ) ) ;
}

if ( ( m_match_flags & match_perl ) && ! ( * m_presult ) [ index ] . matched )
return false ;

BidiIterator i = ( * m_presult ) [ index ] . first ;
BidiIterator j = ( * m_presult ) [ index ] . second ;
while ( i != j )
{
if ( ( position == last ) || ( traits_inst . translate ( * position , icase ) != traits_inst . translate ( * i , icase )
#616
) )
return false ;
++ i ;
++ position ;
}
pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_long_set ( )
{
typedef typename traits :: char_class_type char_class_type ;

if ( position == last )
return false ;
BidiIterator t = re_is_set_member ( position , last , static_cast < const re_set_long < char_class_type > * > ( pstate )
#632
, re . get_data ( ) , icase ) ;
if ( t != position )
{
pstate = pstate -> next . p ;
position = t ;
return true ;
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_set ( )
{
if ( position == last )
return false ;
if ( static_cast < const re_set * > ( pstate ) -> _map [ static_cast < unsigned char > ( traits_inst . translate ( * position
#647
, icase ) ) ] )
{
pstate = pstate -> next . p ;
++ position ;
return true ;
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_jump ( )
{
pstate = static_cast < const re_jump * > ( pstate ) -> alt . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_combining ( )
{
if ( position == last )
return false ;
if ( is_combining ( traits_inst . translate ( * position , icase ) ) )
return false ;
++ position ;
while ( ( position != last ) && is_combining ( traits_inst . translate ( * position , icase ) ) )
++ position ;
pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_soft_buffer_end ( )
{
if ( m_match_flags & match_not_eob )
return false ;
BidiIterator p ( position ) ;
while ( ( p != last ) && is_separator ( traits_inst . translate ( * p , icase ) ) ) ++ p ;
if ( p != last )
return false ;
pstate = pstate -> next . p ;
return true ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_restart_continue ( )
{
if ( position == search_base )
{
pstate = pstate -> next . p ;
return true ;
}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_backstep ( )
{




if ( :: boost :: is_random_access_iterator < BidiIterator > :: value )
{
std :: ptrdiff_t maxlen = :: boost :: re_detail :: distance ( backstop , position ) ;
if ( maxlen < static_cast < const re_brace * > ( pstate ) -> index )
return false ;
std :: advance ( position , - static_cast < const re_brace * > ( pstate ) -> index ) ;
}
else
{
int c = static_cast < const re_brace * > ( pstate ) -> index ;
while ( c -- )
{
if ( position == backstop )
return false ;
-- position ;
}
}
pstate = pstate -> next . p ;
return true ;



}

template < class BidiIterator , class Allocator , class traits >
inline bool perl_matcher < BidiIterator , Allocator , traits > :: match_assert_backref ( )
{

int index = static_cast < const re_brace * > ( pstate ) -> index ;
bool result = false ;
if ( index == 9999 )
{

return false ;
}
else if ( index > 0 )
{


if ( index >= 10000 )
{
named_subexpressions :: range_type r = re . get_data ( ) . equal_range ( index ) ;
while ( r . first != r . second )
{
if ( ( * m_presult ) [ r . first -> index ] . matched )
{
result = true ;
break ;
}
++ r . first ;
}
}
else
{
result = ( * m_presult ) [ index ] . matched ;
}
pstate = pstate -> next . p ;
}
else
{


int idx = - index - 1 ;
if ( idx >= 10000 )
{
named_subexpressions :: range_type r = re . get_data ( ) . equal_range ( idx ) ;
int stack_index = recursion_stack . empty ( ) ? - 1 : recursion_stack . back ( ) . idx ;
while ( r . first != r . second )
{
result |= ( stack_index == r . first -> index ) ;
if ( result ) break ;
++ r . first ;
}
}
else
{
result = ! recursion_stack . empty ( ) && ( ( recursion_stack . back ( ) . idx == idx ) || ( index == 0 ) ) ;
}
pstate = pstate -> next . p ;
}
return result ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: match_toggle_case ( )
{

this -> icase = static_cast < const re_case * > ( pstate ) -> icase ;
pstate = pstate -> next . p ;
return true ;
}


template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: find_restart_any ( )
{




const unsigned char * _map = re . get_map ( ) ;
while ( true )
{

while ( ( position != last ) && ! can_start ( * position , _map , ( unsigned char ) mask_any ) )
++ position ;
if ( position == last )
{

if ( re . can_be_null ( ) )
return match_prefix ( ) ;
break ;
}

if ( match_prefix ( ) )
return true ;
if ( position == last )
return false ;
++ position ;
}
return false ;



}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: find_restart_word ( )
{





const unsigned char * _map = re . get_map ( ) ;
if ( ( m_match_flags & match_prev_avail ) || ( position != base ) )
-- position ;
else if ( match_prefix ( ) )
return true ;
do
{
while ( ( position != last ) && traits_inst . isctype ( * position , m_word_mask ) )
++ position ;
while ( ( position != last ) && ! traits_inst . isctype ( * position , m_word_mask ) )
++ position ;
if ( position == last )
break ;

if ( can_start ( * position , _map , ( unsigned char ) mask_any ) )
{
if ( match_prefix ( ) )
return true ;
}
if ( position == last )
break ;
} while ( true ) ;
return false ;



}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: find_restart_line ( )
{

const unsigned char * _map = re . get_map ( ) ;
if ( match_prefix ( ) )
return true ;
while ( position != last )
{
while ( ( position != last ) && ! is_separator ( * position ) )
++ position ;
if ( position == last )
return false ;
++ position ;
if ( position == last )
{
if ( re . can_be_null ( ) && match_prefix ( ) )
return true ;
return false ;
}

if ( can_start ( * position , _map , ( unsigned char ) mask_any ) )
{
if ( match_prefix ( ) )
return true ;
}
if ( position == last )
return false ;

}
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: find_restart_buf ( )
{
if ( ( position == base ) && ( ( m_match_flags & match_not_bob ) == 0 ) )
return match_prefix ( ) ;
return false ;
}

template < class BidiIterator , class Allocator , class traits >
bool perl_matcher < BidiIterator , Allocator , traits > :: find_restart_lit ( )
{
#970
return false ;
}

}

}
#1 "./boost/regex/v4/instances.hpp"
#25
namespace boost {
#215
}
#1 "./boost/regex/v4/instances.hpp"
#25
namespace boost {
#215
}
#128 "./boost/regex/v4/regex.hpp"
namespace boost {
#136
typedef match_results < const char * > cmatch ;
typedef match_results < std :: string :: const_iterator > smatch ;

typedef match_results < const wchar_t * > wcmatch ;
typedef match_results < std :: wstring :: const_iterator > wsmatch ;


}
#1 "./boost/regex/v4/regex_match.hpp"
#25
namespace boost {
#43
template < class BidiIterator , class Allocator , class charT , class traits >
bool regex_match ( BidiIterator first , BidiIterator last ,
match_results < BidiIterator , Allocator > & m ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
re_detail :: perl_matcher < BidiIterator , Allocator , traits > matcher ( first , last , m , e , flags , first ) ;
return matcher . match ( ) ;
}
template < class iterator , class charT , class traits >
bool regex_match ( iterator first , iterator last ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
match_results < iterator > m ;
return regex_match ( first , last , m , e , flags | regex_constants :: match_any ) ;
}
#67
template < class charT , class Allocator , class traits >
inline bool regex_match ( const charT * str ,
match_results < const charT * , Allocator > & m ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_match ( str , str + traits :: length ( str ) , m , e , flags ) ;
}

template < class ST , class SA , class Allocator , class charT , class traits >
inline bool regex_match ( const std :: basic_string < charT , ST , SA > & s ,
match_results < typename std :: basic_string < charT , ST , SA > :: const_iterator , Allocator > & m ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_match ( s . begin ( ) , s . end ( ) , m , e , flags ) ;
}
template < class charT , class traits >
inline bool regex_match ( const charT * str ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
match_results < const charT * > m ;
return regex_match ( str , str + traits :: length ( str ) , m , e , flags | regex_constants :: match_any ) ;
}

template < class ST , class SA , class charT , class traits >
inline bool regex_match ( const std :: basic_string < charT , ST , SA > & s ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
typedef typename std :: basic_string < charT , ST , SA > :: const_iterator iterator ;
match_results < iterator > m ;
return regex_match ( s . begin ( ) , s . end ( ) , m , e , flags | regex_constants :: match_any ) ;
}
#362
}
#1 "./boost/regex/v4/regex_search.hpp"
#23
namespace boost {
#36
template < class BidiIterator , class Allocator , class charT , class traits >
bool regex_search ( BidiIterator first , BidiIterator last ,
match_results < BidiIterator , Allocator > & m ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_search ( first , last , m , e , flags , first ) ;
}

template < class BidiIterator , class Allocator , class charT , class traits >
bool regex_search ( BidiIterator first , BidiIterator last ,
match_results < BidiIterator , Allocator > & m ,
const basic_regex < charT , traits > & e ,
match_flag_type flags ,
BidiIterator base )
{
if ( e . flags ( ) & regex_constants :: failbit )
return false ;

re_detail :: perl_matcher < BidiIterator , Allocator , traits > matcher ( first , last , m , e , flags , base ) ;
return matcher . find ( ) ;
}
#66
template < class charT , class Allocator , class traits >
inline bool regex_search ( const charT * str ,
match_results < const charT * , Allocator > & m ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_search ( str , str + traits :: length ( str ) , m , e , flags ) ;
}

template < class ST , class SA , class Allocator , class charT , class traits >
inline bool regex_search ( const std :: basic_string < charT , ST , SA > & s ,
match_results < typename std :: basic_string < charT , ST , SA > :: const_iterator , Allocator > & m ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_search ( s . begin ( ) , s . end ( ) , m , e , flags ) ;
}
#134
template < class BidiIterator , class charT , class traits >
bool regex_search ( BidiIterator first , BidiIterator last ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
if ( e . flags ( ) & regex_constants :: failbit )
return false ;

match_results < BidiIterator > m ;
typedef typename match_results < BidiIterator > :: allocator_type match_alloc_type ;
re_detail :: perl_matcher < BidiIterator , match_alloc_type , traits > matcher ( first , last , m , e , flags | regex_constants
#144
:: match_any , first ) ;
return matcher . find ( ) ;
}



template < class charT , class traits >
inline bool regex_search ( const charT * str ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_search ( str , str + traits :: length ( str ) , e , flags ) ;
}

template < class ST , class SA , class charT , class traits >
inline bool regex_search ( const std :: basic_string < charT , ST , SA > & s ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_search ( s . begin ( ) , s . end ( ) , e , flags ) ;
}
#213
}
#1 "./boost/regex/v4/regex_iterator.hpp"
#24
namespace boost {
#37
template < class BidirectionalIterator ,
class charT ,
class traits >
class regex_iterator_implementation
{
typedef basic_regex < charT , traits > regex_type ;

match_results < BidirectionalIterator > what ;
BidirectionalIterator base ;
BidirectionalIterator end ;
const regex_type re ;
match_flag_type flags ;

public :
regex_iterator_implementation ( const regex_type * p , BidirectionalIterator last , match_flag_type f )
: base ( ) , end ( last ) , re ( * p ) , flags ( f ) { }
bool init ( BidirectionalIterator first )
{
base = first ;
return regex_search ( first , end , what , re , flags ) ;
}
bool compare ( const regex_iterator_implementation & that )
{
if ( this == & that ) return true ;
return ( & re . get_data ( ) == & that . re . get_data ( ) ) && ( end == that . end ) && ( flags == that . flags ) && ( what
#61
[ 0 ] . first == that . what [ 0 ] . first ) && ( what [ 0 ] . second == that . what [ 0 ] . second ) ;
}
const match_results < BidirectionalIterator > & get ( )
{ return what ; }
bool next ( )
{


BidirectionalIterator next_start = what [ 0 ] . second ;
match_flag_type f ( flags ) ;
if ( ! what . length ( ) || ( f & regex_constants :: match_posix ) )
f |= regex_constants :: match_not_initial_null ;


bool result = regex_search ( next_start , end , what , re , f , base ) ;
if ( result )
what . set_base ( base ) ;
return result ;
}
private :
regex_iterator_implementation & operator = ( const regex_iterator_implementation & ) ;
} ;

template < class BidirectionalIterator ,
class charT = typename re_detail :: regex_iterator_traits < BidirectionalIterator > :: value_type ,
class traits = regex_traits < charT > >
class regex_iterator

: public std :: iterator <
std :: forward_iterator_tag ,
match_results < BidirectionalIterator > ,
typename re_detail :: regex_iterator_traits < BidirectionalIterator > :: difference_type ,
const match_results < BidirectionalIterator > * ,
const match_results < BidirectionalIterator > & >

{
private :
typedef regex_iterator_implementation < BidirectionalIterator , charT , traits > impl ;
typedef shared_ptr < impl > pimpl ;
public :
typedef basic_regex < charT , traits > regex_type ;
typedef match_results < BidirectionalIterator > value_type ;
typedef typename re_detail :: regex_iterator_traits < BidirectionalIterator > :: difference_type
difference_type ;
typedef const value_type * pointer ;
typedef const value_type & reference ;
typedef std :: forward_iterator_tag iterator_category ;

regex_iterator ( ) { }
regex_iterator ( BidirectionalIterator a , BidirectionalIterator b ,
const regex_type & re ,
match_flag_type m = match_default )
: pdata ( new impl ( & re , b , m ) )
{
if ( ! pdata -> init ( a ) )
{
pdata . reset ( ) ;
}
}
regex_iterator ( const regex_iterator & that )
: pdata ( that . pdata ) { }
regex_iterator & operator = ( const regex_iterator & that )
{
pdata = that . pdata ;
return * this ;
}
bool operator == ( const regex_iterator & that ) const
{
if ( ( pdata . get ( ) == 0 ) || ( that . pdata . get ( ) == 0 ) )
return pdata . get ( ) == that . pdata . get ( ) ;
return pdata -> compare ( * ( that . pdata . get ( ) ) ) ;
}
bool operator != ( const regex_iterator & that ) const
{ return ! ( * this == that ) ; }
const value_type & operator * ( ) const
{ return pdata -> get ( ) ; }
const value_type * operator -> ( ) const
{ return & ( pdata -> get ( ) ) ; }
regex_iterator & operator ++ ( )
{
cow ( ) ;
if ( 0 == pdata -> next ( ) )
{
pdata . reset ( ) ;
}
return * this ;
}
regex_iterator operator ++ ( int )
{
regex_iterator result ( * this ) ;
++ ( * this ) ;
return result ;
}
private :

pimpl pdata ;

void cow ( )
{

if ( pdata . get ( ) && ! pdata . unique ( ) )
{
pdata . reset ( new impl ( * ( pdata . get ( ) ) ) ) ;
}
}
} ;

typedef regex_iterator < const char * > cregex_iterator ;
typedef regex_iterator < std :: string :: const_iterator > sregex_iterator ;

typedef regex_iterator < const wchar_t * > wcregex_iterator ;
typedef regex_iterator < std :: wstring :: const_iterator > wsregex_iterator ;



template < class charT , class traits >
inline regex_iterator < const charT * , charT , traits > make_regex_iterator ( const charT * p , const basic_regex < charT
#177
, traits > & e , regex_constants :: match_flag_type m = regex_constants :: match_default )
{
return regex_iterator < const charT * , charT , traits > ( p , p + traits :: length ( p ) , e , m ) ;
}
template < class charT , class traits , class ST , class SA >
inline regex_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > make_regex_iterator
#182
( const std :: basic_string < charT , ST , SA > & p , const basic_regex < charT , traits > & e , regex_constants :: match_flag_type
#182
m = regex_constants :: match_default )
{
return regex_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > ( p . begin
#184
( ) , p . end ( ) , e , m ) ;
}
#198
}
#1 "./boost/regex/v4/regex_token_iterator.hpp"
#37
namespace boost {
#54
template < class BidirectionalIterator ,
class charT ,
class traits >
class regex_token_iterator_implementation
{
typedef basic_regex < charT , traits > regex_type ;
typedef sub_match < BidirectionalIterator > value_type ;

match_results < BidirectionalIterator > what ;
BidirectionalIterator base ;
BidirectionalIterator end ;
const regex_type re ;
match_flag_type flags ;
value_type result ;
int N ;
std :: vector < int > subs ;

public :
regex_token_iterator_implementation ( const regex_type * p , BidirectionalIterator last , int sub , match_flag_type f )
: end ( last ) , re ( * p ) , flags ( f ) { subs . push_back ( sub ) ; }
regex_token_iterator_implementation ( const regex_type * p , BidirectionalIterator last , const std :: vector < int > & v
#74
, match_flag_type f )
: end ( last ) , re ( * p ) , flags ( f ) , subs ( v ) { }
#94
template < std :: size_t CN >
regex_token_iterator_implementation ( const regex_type * p , BidirectionalIterator last , const int ( & submatches ) [ CN
#95
] , match_flag_type f )
: end ( last ) , re ( * p ) , flags ( f )
{
for ( std :: size_t i = 0 ; i < CN ; ++ i )
{
subs . push_back ( submatches [ i ] ) ;
}
}


bool init ( BidirectionalIterator first )
{
N = 0 ;
base = first ;
if ( regex_search ( first , end , what , re , flags , base ) == true )
{
N = 0 ;
result = ( ( subs [ N ] == - 1 ) ? what . prefix ( ) : what [ ( int ) subs [ N ] ] ) ;
return true ;
}
else if ( ( subs [ N ] == - 1 ) && ( first != end ) )
{
result . first = first ;
result . second = end ;
result . matched = ( first != end ) ;
N = - 1 ;
return true ;
}
return false ;
}
bool compare ( const regex_token_iterator_implementation & that )
{
if ( this == & that ) return true ;
return ( & re . get_data ( ) == & that . re . get_data ( ) )
&& ( end == that . end )
&& ( flags == that . flags )
&& ( N == that . N )
&& ( what [ 0 ] . first == that . what [ 0 ] . first )
&& ( what [ 0 ] . second == that . what [ 0 ] . second ) ;
}
const value_type & get ( )
{ return result ; }
bool next ( )
{
if ( N == - 1 )
return false ;
if ( N + 1 < ( int ) subs . size ( ) )
{
++ N ;
result = ( ( subs [ N ] == - 1 ) ? what . prefix ( ) : what [ subs [ N ] ] ) ;
return true ;
}


BidirectionalIterator last_end ( what [ 0 ] . second ) ;
if ( regex_search ( last_end , end , what , re , ( ( what [ 0 ] . first == what [ 0 ] . second ) ? flags | regex_constants
#150
:: match_not_initial_null : flags ) , base ) )
{
N = 0 ;
result = ( ( subs [ N ] == - 1 ) ? what . prefix ( ) : what [ subs [ N ] ] ) ;
return true ;
}
else if ( ( last_end != end ) && ( subs [ 0 ] == - 1 ) )
{
N = - 1 ;
result . first = last_end ;
result . second = end ;
result . matched = ( last_end != end ) ;
return true ;
}
return false ;
}
private :
regex_token_iterator_implementation & operator = ( const regex_token_iterator_implementation & ) ;
} ;

template < class BidirectionalIterator ,
class charT = typename re_detail :: regex_iterator_traits < BidirectionalIterator > :: value_type ,
class traits = regex_traits < charT > >
class regex_token_iterator

: public std :: iterator <
std :: forward_iterator_tag ,
sub_match < BidirectionalIterator > ,
typename re_detail :: regex_iterator_traits < BidirectionalIterator > :: difference_type ,
const sub_match < BidirectionalIterator > * ,
const sub_match < BidirectionalIterator > & >

{
private :
typedef regex_token_iterator_implementation < BidirectionalIterator , charT , traits > impl ;
typedef shared_ptr < impl > pimpl ;
public :
typedef basic_regex < charT , traits > regex_type ;
typedef sub_match < BidirectionalIterator > value_type ;
typedef typename re_detail :: regex_iterator_traits < BidirectionalIterator > :: difference_type
difference_type ;
typedef const value_type * pointer ;
typedef const value_type & reference ;
typedef std :: forward_iterator_tag iterator_category ;

regex_token_iterator ( ) { }
regex_token_iterator ( BidirectionalIterator a , BidirectionalIterator b , const regex_type & re ,
int submatch = 0 , match_flag_type m = match_default )
: pdata ( new impl ( & re , b , submatch , m ) )
{
if ( ! pdata -> init ( a ) )
pdata . reset ( ) ;
}
regex_token_iterator ( BidirectionalIterator a , BidirectionalIterator b , const regex_type & re ,
const std :: vector < int > & submatches , match_flag_type m = match_default )
: pdata ( new impl ( & re , b , submatches , m ) )
{
if ( ! pdata -> init ( a ) )
pdata . reset ( ) ;
}
#224
template < std :: size_t N >
regex_token_iterator ( BidirectionalIterator a , BidirectionalIterator b , const regex_type & re ,
const int ( & submatches ) [ N ] , match_flag_type m = match_default )
: pdata ( new impl ( & re , b , submatches , m ) )
{
if ( ! pdata -> init ( a ) )
pdata . reset ( ) ;
}


regex_token_iterator ( const regex_token_iterator & that )
: pdata ( that . pdata ) { }
regex_token_iterator & operator = ( const regex_token_iterator & that )
{
pdata = that . pdata ;
return * this ;
}
bool operator == ( const regex_token_iterator & that ) const
{
if ( ( pdata . get ( ) == 0 ) || ( that . pdata . get ( ) == 0 ) )
return pdata . get ( ) == that . pdata . get ( ) ;
return pdata -> compare ( * ( that . pdata . get ( ) ) ) ;
}
bool operator != ( const regex_token_iterator & that ) const
{ return ! ( * this == that ) ; }
const value_type & operator * ( ) const
{ return pdata -> get ( ) ; }
const value_type * operator -> ( ) const
{ return & ( pdata -> get ( ) ) ; }
regex_token_iterator & operator ++ ( )
{
cow ( ) ;
if ( 0 == pdata -> next ( ) )
{
pdata . reset ( ) ;
}
return * this ;
}
regex_token_iterator operator ++ ( int )
{
regex_token_iterator result ( * this ) ;
++ ( * this ) ;
return result ;
}
private :

pimpl pdata ;

void cow ( )
{

if ( pdata . get ( ) && ! pdata . unique ( ) )
{
pdata . reset ( new impl ( * ( pdata . get ( ) ) ) ) ;
}
}
} ;

typedef regex_token_iterator < const char * > cregex_token_iterator ;
typedef regex_token_iterator < std :: string :: const_iterator > sregex_token_iterator ;

typedef regex_token_iterator < const wchar_t * > wcregex_token_iterator ;
typedef regex_token_iterator < std :: wstring :: const_iterator > wsregex_token_iterator ;


template < class charT , class traits >
inline regex_token_iterator < const charT * , charT , traits > make_regex_token_iterator ( const charT * p , const basic_regex
#290
< charT , traits > & e , int submatch = 0 , regex_constants :: match_flag_type m = regex_constants :: match_default )
{
return regex_token_iterator < const charT * , charT , traits > ( p , p + traits :: length ( p ) , e , submatch , m ) ;
}
template < class charT , class traits , class ST , class SA >
inline regex_token_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > make_regex_token_iterator
#295
( const std :: basic_string < charT , ST , SA > & p , const basic_regex < charT , traits > & e , int submatch = 0 , regex_constants
#295
:: match_flag_type m = regex_constants :: match_default )
{
return regex_token_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > ( p .
#297
begin ( ) , p . end ( ) , e , submatch , m ) ;
}

template < class charT , class traits , std :: size_t N >
inline regex_token_iterator < const charT * , charT , traits > make_regex_token_iterator ( const charT * p , const basic_regex
#301
< charT , traits > & e , const int ( & submatch ) [ N ] , regex_constants :: match_flag_type m = regex_constants :: match_default
#301
)
{
return regex_token_iterator < const charT * , charT , traits > ( p , p + traits :: length ( p ) , e , submatch , m ) ;
}
template < class charT , class traits , class ST , class SA , std :: size_t N >
inline regex_token_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > make_regex_token_iterator
#306
( const std :: basic_string < charT , ST , SA > & p , const basic_regex < charT , traits > & e , const int ( & submatch )
#306
[ N ] , regex_constants :: match_flag_type m = regex_constants :: match_default )
{
return regex_token_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > ( p .
#308
begin ( ) , p . end ( ) , e , submatch , m ) ;
}

template < class charT , class traits >
inline regex_token_iterator < const charT * , charT , traits > make_regex_token_iterator ( const charT * p , const basic_regex
#312
< charT , traits > & e , const std :: vector < int > & submatch , regex_constants :: match_flag_type m = regex_constants
#312
:: match_default )
{
return regex_token_iterator < const charT * , charT , traits > ( p , p + traits :: length ( p ) , e , submatch , m ) ;
}
template < class charT , class traits , class ST , class SA >
inline regex_token_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > make_regex_token_iterator
#317
( const std :: basic_string < charT , ST , SA > & p , const basic_regex < charT , traits > & e , const std :: vector < int
#317
> & submatch , regex_constants :: match_flag_type m = regex_constants :: match_default )
{
return regex_token_iterator < typename std :: basic_string < charT , ST , SA > :: const_iterator , charT , traits > ( p .
#319
begin ( ) , p . end ( ) , e , submatch , m ) ;
}
#336
}
#1 "./boost/regex/v4/regex_grep.hpp"
#23
namespace boost {
#40
template < class Predicate , class BidiIterator , class charT , class traits >
inline unsigned int regex_grep ( Predicate foo ,
BidiIterator first ,
BidiIterator last ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
if ( e . flags ( ) & regex_constants :: failbit )
return false ;

typedef typename match_results < BidiIterator > :: allocator_type match_allocator_type ;

match_results < BidiIterator > m ;
re_detail :: perl_matcher < BidiIterator , match_allocator_type , traits > matcher ( first , last , m , e , flags , first
#53
) ;
unsigned int count = 0 ;
while ( matcher . find ( ) )
{
++ count ;
if ( 0 == foo ( m ) )
return count ;
if ( m [ 0 ] . second == last )
return count ;
if ( m . length ( ) == 0 )
{
if ( m [ 0 ] . second == last )
return count ;


match_results < BidiIterator , match_allocator_type > m2 ( m ) ;
matcher . setf ( match_not_null | match_continuous ) ;
if ( matcher . find ( ) )
{
++ count ;
if ( 0 == foo ( m ) )
return count ;
}
else
{

m = m2 ;
}
matcher . unsetf ( ( match_not_null | match_continuous ) & ~ flags ) ;
}
}
return count ;
}
#94
template < class Predicate , class charT , class traits >
inline unsigned int regex_grep ( Predicate foo , const charT * str ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_grep ( foo , str , str + traits :: length ( str ) , e , flags ) ;
}

template < class Predicate , class ST , class SA , class charT , class traits >
inline unsigned int regex_grep ( Predicate foo , const std :: basic_string < charT , ST , SA > & s ,
const basic_regex < charT , traits > & e ,
match_flag_type flags = match_default )
{
return regex_grep ( foo , s . begin ( ) , s . end ( ) , e , flags ) ;
}
#152
}
#1 "./boost/regex/v4/regex_replace.hpp"
#25
namespace boost {
#38
template < class OutputIterator , class BidirectionalIterator , class traits , class charT , class Formatter >
OutputIterator regex_replace ( OutputIterator out ,
BidirectionalIterator first ,
BidirectionalIterator last ,
const basic_regex < charT , traits > & e ,
Formatter fmt ,
match_flag_type flags = match_default )
{
regex_iterator < BidirectionalIterator , charT , traits > i ( first , last , e , flags ) ;
regex_iterator < BidirectionalIterator , charT , traits > j ;
if ( i == j )
{
if ( ! ( flags & regex_constants :: format_no_copy ) )
out = re_detail :: copy ( first , last , out ) ;
}
else
{
BidirectionalIterator last_m ( first ) ;
while ( i != j )
{
if ( ! ( flags & regex_constants :: format_no_copy ) )
out = re_detail :: copy ( i -> prefix ( ) . first , i -> prefix ( ) . second , out ) ;
out = i -> format ( out , fmt , flags , e ) ;
last_m = ( * i ) [ 0 ] . second ;
if ( flags & regex_constants :: format_first_only )
break ;
++ i ;
}
if ( ! ( flags & regex_constants :: format_no_copy ) )
out = re_detail :: copy ( last_m , last , out ) ;
}
return out ;
}

template < class traits , class charT , class Formatter >
std :: basic_string < charT > regex_replace ( const std :: basic_string < charT > & s ,
const basic_regex < charT , traits > & e ,
Formatter fmt ,
match_flag_type flags = match_default )
{
std :: basic_string < charT > result ;
re_detail :: string_out_iterator < std :: basic_string < charT > > i ( result ) ;
regex_replace ( i , s . begin ( ) , s . end ( ) , e , fmt , flags ) ;
return result ;
}
#95
}
#1 "./boost/regex/v4/regex_merge.hpp"
#25
namespace boost {
#38
template < class OutputIterator , class Iterator , class traits , class charT >
inline OutputIterator regex_merge ( OutputIterator out ,
Iterator first ,
Iterator last ,
const basic_regex < charT , traits > & e ,
const charT * fmt ,
match_flag_type flags = match_default )
{
return regex_replace ( out , first , last , e , fmt , flags ) ;
}

template < class OutputIterator , class Iterator , class traits , class charT >
inline OutputIterator regex_merge ( OutputIterator out ,
Iterator first ,
Iterator last ,
const basic_regex < charT , traits > & e ,
const std :: basic_string < charT > & fmt ,
match_flag_type flags = match_default )
{
return regex_merge ( out , first , last , e , fmt . c_str ( ) , flags ) ;
}

template < class traits , class charT >
inline std :: basic_string < charT > regex_merge ( const std :: basic_string < charT > & s ,
const basic_regex < charT , traits > & e ,
const charT * fmt ,
match_flag_type flags = match_default )
{
return regex_replace ( s , e , fmt , flags ) ;
}

template < class traits , class charT >
inline std :: basic_string < charT > regex_merge ( const std :: basic_string < charT > & s ,
const basic_regex < charT , traits > & e ,
const std :: basic_string < charT > & fmt ,
match_flag_type flags = match_default )
{
return regex_replace ( s , e , fmt , flags ) ;
}
#89
}
#1 "./boost/regex/v4/regex_split.hpp"
#24
namespace boost {
#42
namespace re_detail {

template < class charT >
const basic_regex < charT > & get_default_expression ( charT )
{
static const charT expression_text [ 4 ] = { '\\' , 's' , '+' , '\00' , } ;
static const basic_regex < charT > e ( expression_text ) ;
return e ;
}

template < class OutputIterator , class charT , class Traits1 , class Alloc1 >
class split_pred
{
typedef std :: basic_string < charT , Traits1 , Alloc1 > string_type ;
typedef typename string_type :: const_iterator iterator_type ;
iterator_type * p_last ;
OutputIterator * p_out ;
std :: size_t * p_max ;
std :: size_t initial_max ;
public :
split_pred ( iterator_type * a , OutputIterator * b , std :: size_t * c )
: p_last ( a ) , p_out ( b ) , p_max ( c ) , initial_max ( * c ) { }

bool operator ( ) ( const match_results < iterator_type > & what ) ;
} ;

template < class OutputIterator , class charT , class Traits1 , class Alloc1 >
bool split_pred < OutputIterator , charT , Traits1 , Alloc1 > :: operator ( )
( const match_results < iterator_type > & what )
{
* p_last = what [ 0 ] . second ;
if ( what . size ( ) > 1 )
{

for ( unsigned i = 1 ; i < what . size ( ) ; ++ i )
{
* ( * p_out ) = what . str ( i ) ;
++ ( * p_out ) ;
if ( 0 == -- * p_max ) return false ;
}
return * p_max != 0 ;
}
else
{

const sub_match < iterator_type > & sub = what [ - 1 ] ;
if ( ( sub . first != sub . second ) || ( * p_max != initial_max ) )
{
* ( * p_out ) = sub . str ( ) ;
++ ( * p_out ) ;
return -- * p_max ;
}
}


return true ;
}

}

template < class OutputIterator , class charT , class Traits1 , class Alloc1 , class Traits2 >
std :: size_t regex_split ( OutputIterator out ,
std :: basic_string < charT , Traits1 , Alloc1 > & s ,
const basic_regex < charT , Traits2 > & e ,
match_flag_type flags ,
std :: size_t max_split )
{
typedef typename std :: basic_string < charT , Traits1 , Alloc1 > :: const_iterator ci_t ;

ci_t last = s . begin ( ) ;
std :: size_t init_size = max_split ;
re_detail :: split_pred < OutputIterator , charT , Traits1 , Alloc1 > pred ( & last , & out , & max_split ) ;
ci_t i , j ;
i = s . begin ( ) ;
j = s . end ( ) ;
regex_grep ( pred , i , j , e , flags ) ;




if ( max_split && ( last != s . end ( ) ) && ( e . mark_count ( ) == 1 ) )
{
* out = std :: basic_string < charT , Traits1 , Alloc1 > ( ( ci_t ) last , ( ci_t ) s . end ( ) ) ;
++ out ;
last = s . end ( ) ;
-- max_split ;
}


s . erase ( 0 , last - s . begin ( ) ) ;


return init_size - max_split ;
}

template < class OutputIterator , class charT , class Traits1 , class Alloc1 , class Traits2 >
inline std :: size_t regex_split ( OutputIterator out ,
std :: basic_string < charT , Traits1 , Alloc1 > & s ,
const basic_regex < charT , Traits2 > & e ,
match_flag_type flags = match_default )
{
return regex_split ( out , s , e , flags , 4294967295U ) ;
}

template < class OutputIterator , class charT , class Traits1 , class Alloc1 >
inline std :: size_t regex_split ( OutputIterator out ,
std :: basic_string < charT , Traits1 , Alloc1 > & s )
{
return regex_split ( out , s , re_detail :: get_default_expression ( charT ( 0 ) ) , match_default , 4294967295U ) ;
}
#168
}
#1 "./boost/cregex.hpp"
#1 "./boost/regex/v4/cregex.hpp"
#48
namespace boost {
extern "C" {



typedef std :: ptrdiff_t regoff_t ;
typedef std :: size_t regsize_t ;





typedef struct
{
unsigned int re_magic ;

std :: size_t re_nsub ;



const char * re_endp ;
void * guts ;
match_flag_type eflags ;
} regex_tA ;


typedef struct
{
unsigned int re_magic ;

std :: size_t re_nsub ;



const wchar_t * re_endp ;
void * guts ;
match_flag_type eflags ;
} regex_tW ;


typedef struct
{
regoff_t rm_so ;
regoff_t rm_eo ;
} regmatch_t ;


typedef enum {
REG_BASIC = 0000 ,
REG_EXTENDED = 0001 ,
REG_ICASE = 0002 ,
REG_NOSUB = 0004 ,
REG_NEWLINE = 0010 ,
REG_NOSPEC = 0020 ,
REG_PEND = 0040 ,
REG_DUMP = 0200 ,
REG_NOCOLLATE = 0400 ,
REG_ESCAPE_IN_LISTS = 01000 ,
REG_NEWLINE_ALT = 02000 ,
REG_PERLEX = 04000 ,

REG_PERL = REG_EXTENDED | REG_NOCOLLATE | REG_ESCAPE_IN_LISTS | REG_PERLEX ,
REG_AWK = REG_EXTENDED | REG_ESCAPE_IN_LISTS ,
REG_GREP = REG_BASIC | REG_NEWLINE_ALT ,
REG_EGREP = REG_EXTENDED | REG_NEWLINE_ALT ,

REG_ASSERT = 15 ,
REG_INVARG = 16 ,
REG_ATOI = 255 ,
REG_ITOA = 0400
} reg_comp_flags ;


typedef enum {
REG_NOTBOL = 00001 ,
REG_NOTEOL = 00002 ,
REG_STARTEND = 00004
} reg_exec_flags ;




typedef unsigned reg_error_t ;
typedef reg_error_t reg_errcode_t ;

static const reg_error_t REG_NOERROR = 0 ;
static const reg_error_t REG_NOMATCH = 1 ;



static const reg_error_t REG_BADPAT = 2 ;
static const reg_error_t REG_ECOLLATE = 3 ;
static const reg_error_t REG_ECTYPE = 4 ;
static const reg_error_t REG_EESCAPE = 5 ;
static const reg_error_t REG_ESUBREG = 6 ;
static const reg_error_t REG_EBRACK = 7 ;
static const reg_error_t REG_EPAREN = 8 ;
static const reg_error_t REG_EBRACE = 9 ;
static const reg_error_t REG_BADBR = 10 ;
static const reg_error_t REG_ERANGE = 11 ;
static const reg_error_t REG_ESPACE = 12 ;
static const reg_error_t REG_BADRPT = 13 ;
static const reg_error_t REG_EEND = 14 ;
static const reg_error_t REG_ESIZE = 15 ;
static const reg_error_t REG_ERPAREN = 8 ;
static const reg_error_t REG_EMPTY = 17 ;
static const reg_error_t REG_E_MEMORY = 15 ;
static const reg_error_t REG_ECOMPLEXITY = 18 ;
static const reg_error_t REG_ESTACK = 19 ;
static const reg_error_t REG_E_PERL = 20 ;
static const reg_error_t REG_E_UNKNOWN = 21 ;
static const reg_error_t REG_ENOSYS = 21 ;

int regcompA ( regex_tA * , const char * , int ) ;
regsize_t regerrorA ( int , const regex_tA * , char * , regsize_t ) ;
int regexecA ( const regex_tA * , const char * , regsize_t , regmatch_t * , int ) ;
void regfreeA ( regex_tA * ) ;


int regcompW ( regex_tW * , const wchar_t * , int ) ;
regsize_t regerrorW ( int , const regex_tW * , wchar_t * , regsize_t ) ;
int regexecW ( const regex_tW * , const wchar_t * , regsize_t , regmatch_t * , int ) ;
void regfreeW ( regex_tW * ) ;
#199
}
}
#209
namespace boost {
#222
class RegEx ;

namespace re_detail {

class RegExData ;
struct pred1 ;
struct pred2 ;
struct pred3 ;
struct pred4 ;

}
#239
typedef bool ( * GrepCallback ) ( const RegEx & expression ) ;
typedef bool ( * GrepFileCallback ) ( const char * file , const RegEx & expression ) ;
typedef bool ( * FindFilesCallback ) ( const char * file ) ;


class RegEx
{
private :
re_detail :: RegExData * pdata ;
public :
RegEx ( ) ;
RegEx ( const RegEx & o ) ;
~ RegEx ( ) ;
explicit RegEx ( const char * c , bool icase = false ) ;
explicit RegEx ( const std :: string & s , bool icase = false ) ;
RegEx & operator = ( const RegEx & o ) ;
RegEx & operator = ( const char * p ) ;
RegEx & operator = ( const std :: string & s ) { return this -> operator = ( s . c_str ( ) ) ; }
unsigned int SetExpression ( const char * p , bool icase = false ) ;
unsigned int SetExpression ( const std :: string & s , bool icase = false ) { return SetExpression ( s . c_str ( ) , icase
#258
) ; }
std :: string Expression ( ) const ;
unsigned int error_code ( ) const ;



bool Match ( const char * p , match_flag_type flags = match_default ) ;
bool Match ( const std :: string & s , match_flag_type flags = match_default ) { return Match ( s . c_str ( ) , flags ) ;
#265
}
bool Search ( const char * p , match_flag_type flags = match_default ) ;
bool Search ( const std :: string & s , match_flag_type flags = match_default ) { return Search ( s . c_str ( ) , flags )
#267
; }
unsigned int Grep ( GrepCallback cb , const char * p , match_flag_type flags = match_default ) ;
unsigned int Grep ( GrepCallback cb , const std :: string & s , match_flag_type flags = match_default ) { return Grep ( cb
#269
, s . c_str ( ) , flags ) ; }
unsigned int Grep ( std :: vector < std :: string > & v , const char * p , match_flag_type flags = match_default ) ;
unsigned int Grep ( std :: vector < std :: string > & v , const std :: string & s , match_flag_type flags = match_default
#271
) { return Grep ( v , s . c_str ( ) , flags ) ; }
unsigned int Grep ( std :: vector < std :: size_t > & v , const char * p , match_flag_type flags = match_default ) ;
unsigned int Grep ( std :: vector < std :: size_t > & v , const std :: string & s , match_flag_type flags = match_default
#273
) { return Grep ( v , s . c_str ( ) , flags ) ; }

unsigned int GrepFiles ( GrepFileCallback cb , const char * files , bool recurse = false , match_flag_type flags = match_default
#275
) ;
unsigned int GrepFiles ( GrepFileCallback cb , const std :: string & files , bool recurse = false , match_flag_type flags
#276
= match_default ) { return GrepFiles ( cb , files . c_str ( ) , recurse , flags ) ; }
unsigned int FindFiles ( FindFilesCallback cb , const char * files , bool recurse = false , match_flag_type flags = match_default
#277
) ;
unsigned int FindFiles ( FindFilesCallback cb , const std :: string & files , bool recurse = false , match_flag_type flags
#278
= match_default ) { return FindFiles ( cb , files . c_str ( ) , recurse , flags ) ; }


std :: string Merge ( const std :: string & in , const std :: string & fmt ,
bool copy = true , match_flag_type flags = match_default ) ;
std :: string Merge ( const char * in , const char * fmt ,
bool copy = true , match_flag_type flags = match_default ) ;

std :: size_t Split ( std :: vector < std :: string > & v , std :: string & s , match_flag_type flags = match_default , unsigned
#286
max_count = ~ 0 ) ;



std :: size_t Position ( int i = 0 ) const ;
std :: size_t Length ( int i = 0 ) const ;
bool Matched ( int i = 0 ) const ;
std :: size_t Marks ( ) const ;
std :: string What ( int i = 0 ) const ;
std :: string operator [ ] ( int i ) const { return What ( i ) ; }

static const std :: size_t npos ;

friend struct re_detail :: pred1 ;
friend struct re_detail :: pred2 ;
friend struct re_detail :: pred3 ;
friend struct re_detail :: pred4 ;
} ;
#316
}
#1 "./boost/regex/v4/fileiter.hpp"
#1 "./boost/assert.hpp"
#1 "/usr/include/assert.h"
#1 "/opt/SolarisStudio12.4-beta_jul14-solaris-x86/lib/compilers/CC-gcc/include/c++/4.8.2/cassert"
#41
#pragma GCC system_header
#1 "/usr/include/assert.h"
#1 "/usr/include/dirent.h"
#16
#pragma ident "@(#)dirent.h 1.37    04/09/28 SMI"
#1 "/usr/include/sys/dirent.h"
#16
#pragma ident "@(#)dirent.h 1.36    04/09/28 SMI"
#21
extern "C" {





typedef struct dirent {
ino_t d_ino ;
off_t d_off ;
unsigned short d_reclen ;
char d_name [ 1 ] ;
} dirent_t ;
#52
typedef struct dirent64 {
ino64_t d_ino ;
off64_t d_off ;
unsigned short d_reclen ;
char d_name [ 1 ] ;
} dirent64_t ;
#93
#pragma redefine_extname getdents64 getdents
#102
extern int getdents ( int , struct dirent * , size_t ) ;
#113
}
#24 "/usr/include/dirent.h"
extern "C" {
#46
typedef struct {
int d_fd ;
int d_loc ;
int d_size ;
char * d_buf ;
} DIR ;
#73
#pragma redefine_extname readdir64 readdir
#pragma redefine_extname scandir64 scandir
#pragma redefine_extname alphasort64 alphasort
#83
extern DIR * opendir ( const char * ) ;


extern DIR * fdopendir ( int ) ;


extern int scandir ( const char * , struct dirent * ( * [ ] ) ,
int ( * ) ( const struct dirent * ) ,
int ( * ) ( const struct dirent * * ,
const struct dirent * * ) ) ;
extern int alphasort ( const struct dirent * * ,
const struct dirent * * ) ;

extern struct dirent * readdir ( DIR * ) ;


extern long telldir ( DIR * ) ;
extern void seekdir ( DIR * , long ) ;

extern void rewinddir ( DIR * ) ;
extern int closedir ( DIR * ) ;




extern struct dirent64 * readdir64 ( DIR * ) ;

extern int scandir64 ( const char * , struct dirent64 * ( * [ ] ) ,
int ( * ) ( const struct dirent64 * ) ,
int ( * ) ( const struct dirent64 * * ,
const struct dirent64 * * ) ) ;
extern int alphasort64 ( const struct dirent64 * * , const struct dirent64 * * ) ;
#204
#pragma redefine_extname readdir64_r readdir_r
#215
extern int readdir_r ( DIR * , struct dirent * ,
struct dirent * * ) ;
#223
extern int readdir64_r ( DIR * , struct dirent64 * ,
struct dirent64 * * ) ;
#290
}
#79 "./boost/regex/v4/fileiter.hpp"
using std :: list ;
#86
namespace boost {
namespace re_detail {





struct _fi_find_data
{
unsigned dwFileAttributes ;
char cFileName [ 256 ] ;
} ;

struct _fi_priv_data ;

typedef _fi_priv_data * _fi_find_handle ;



_fi_find_handle _fi_FindFirstFile ( const char * lpFileName , _fi_find_data * lpFindFileData ) ;
bool _fi_FindNextFile ( _fi_find_handle hFindFile , _fi_find_data * lpFindFileData ) ;
bool _fi_FindClose ( _fi_find_handle hFindFile ) ;





}
}
#132
namespace boost {
namespace re_detail {
#165
class mapfile_iterator ;

class mapfile
{
typedef char * pointer ;
std :: FILE * hfile ;
long int _size ;
pointer * _first ;
pointer * _last ;
mutable std :: list < pointer * > condemed ;
enum sizes
{
buf_size = 4096
} ;
void lock ( pointer * node ) const ;
void unlock ( pointer * node ) const ;
public :

typedef mapfile_iterator iterator ;

mapfile ( ) { hfile = 0 ; _size = 0 ; _first = _last = 0 ; }
mapfile ( const char * file ) { hfile = 0 ; _size = 0 ; _first = _last = 0 ; open ( file ) ; }
~ mapfile ( ) { close ( ) ; }
void open ( const char * file ) ;
void close ( ) ;
iterator begin ( ) const ;
iterator end ( ) const ;
unsigned long size ( ) const { return _size ; }
bool valid ( ) const { return hfile != 0 ; }
friend class mapfile_iterator ;
} ;

class mapfile_iterator

: public std :: iterator < std :: random_access_iterator_tag , char >

{
typedef mapfile :: pointer internal_pointer ;
internal_pointer * node ;
const mapfile * file ;
unsigned long offset ;
long position ( ) const
{
return file ? ( ( node - file -> _first ) * mapfile :: buf_size + offset ) : 0 ;
}
void position ( long pos )
{
if ( file )
{
node = file -> _first + ( pos / mapfile :: buf_size ) ;
offset = pos % mapfile :: buf_size ;
}
}
public :
typedef std :: ptrdiff_t difference_type ;
typedef char value_type ;
typedef const char * pointer ;
typedef const char & reference ;
typedef std :: random_access_iterator_tag iterator_category ;

mapfile_iterator ( ) { node = 0 ; file = 0 ; offset = 0 ; }
mapfile_iterator ( const mapfile * f , long arg_position )
{
file = f ;
node = f -> _first + arg_position / mapfile :: buf_size ;
offset = arg_position % mapfile :: buf_size ;
if ( file )
file -> lock ( node ) ;
}
mapfile_iterator ( const mapfile_iterator & i )
{
file = i . file ;
node = i . node ;
offset = i . offset ;
if ( file )
file -> lock ( node ) ;
}
~ mapfile_iterator ( )
{
if ( file && node )
file -> unlock ( node ) ;
}
mapfile_iterator & operator = ( const mapfile_iterator & i ) ;
char operator * ( ) const
{
( ( void ) 0 ) ;
( ( void ) 0 ) ;
return file ? * ( * node + sizeof ( int ) + offset ) : char ( 0 ) ;
}
char operator [ ] ( long off ) const
{
mapfile_iterator tmp ( * this ) ;
tmp += off ;
return * tmp ;
}
mapfile_iterator & operator ++ ( ) ;
mapfile_iterator operator ++ ( int ) ;
mapfile_iterator & operator -- ( ) ;
mapfile_iterator operator -- ( int ) ;

mapfile_iterator & operator += ( long off )
{
position ( position ( ) + off ) ;
return * this ;
}
mapfile_iterator & operator -= ( long off )
{
position ( position ( ) - off ) ;
return * this ;
}

friend inline bool operator == ( const mapfile_iterator & i , const mapfile_iterator & j )
{
return ( i . file == j . file ) && ( i . node == j . node ) && ( i . offset == j . offset ) ;
}

friend inline bool operator != ( const mapfile_iterator & i , const mapfile_iterator & j )
{
return ! ( i == j ) ;
}

friend inline bool operator < ( const mapfile_iterator & i , const mapfile_iterator & j )
{
return i . position ( ) < j . position ( ) ;
}
friend inline bool operator > ( const mapfile_iterator & i , const mapfile_iterator & j )
{
return i . position ( ) > j . position ( ) ;
}
friend inline bool operator <= ( const mapfile_iterator & i , const mapfile_iterator & j )
{
return i . position ( ) <= j . position ( ) ;
}
friend inline bool operator >= ( const mapfile_iterator & i , const mapfile_iterator & j )
{
return i . position ( ) >= j . position ( ) ;
}

friend mapfile_iterator operator + ( const mapfile_iterator & i , long off ) ;
friend mapfile_iterator operator + ( long off , const mapfile_iterator & i )
{
mapfile_iterator tmp ( i ) ;
return tmp += off ;
}
friend mapfile_iterator operator - ( const mapfile_iterator & i , long off ) ;
friend inline long operator - ( const mapfile_iterator & i , const mapfile_iterator & j )
{
return i . position ( ) - j . position ( ) ;
}
} ;




extern const char * _fi_sep ;

struct file_iterator_ref
{
_fi_find_handle hf ;
_fi_find_data _data ;
long count ;
} ;


class file_iterator
{
char * _root ;
char * _path ;
char * ptr ;
file_iterator_ref * ref ;

public :
typedef std :: ptrdiff_t difference_type ;
typedef const char * value_type ;
typedef const char * * pointer ;
typedef const char * & reference ;
typedef std :: input_iterator_tag iterator_category ;

file_iterator ( ) ;
file_iterator ( const char * wild ) ;
~ file_iterator ( ) ;
file_iterator ( const file_iterator & ) ;
file_iterator & operator = ( const file_iterator & ) ;
const char * root ( ) const { return _root ; }
const char * path ( ) const { return _path ; }
const char * name ( ) const { return ptr ; }
_fi_find_data * data ( ) { return & ( ref -> _data ) ; }
void next ( ) ;
file_iterator & operator ++ ( ) { next ( ) ; return * this ; }
file_iterator operator ++ ( int ) ;
const char * operator * ( ) { return path ( ) ; }

friend inline bool operator == ( const file_iterator & f1 , const file_iterator & f2 )
{
return ( ( f1 . ref -> hf == 0 ) && ( f2 . ref -> hf == 0 ) ) ;
}

friend inline bool operator != ( const file_iterator & f1 , const file_iterator & f2 )
{
return ! ( f1 == f2 ) ;
}

} ;


inline bool operator < ( const file_iterator & , const file_iterator & )
{
return false ;
}


class directory_iterator
{
char * _root ;
char * _path ;
char * ptr ;
file_iterator_ref * ref ;

public :
typedef std :: ptrdiff_t difference_type ;
typedef const char * value_type ;
typedef const char * * pointer ;
typedef const char * & reference ;
typedef std :: input_iterator_tag iterator_category ;

directory_iterator ( ) ;
directory_iterator ( const char * wild ) ;
~ directory_iterator ( ) ;
directory_iterator ( const directory_iterator & other ) ;
directory_iterator & operator = ( const directory_iterator & other ) ;

const char * root ( ) const { return _root ; }
const char * path ( ) const { return _path ; }
const char * name ( ) const { return ptr ; }
_fi_find_data * data ( ) { return & ( ref -> _data ) ; }
void next ( ) ;
directory_iterator & operator ++ ( ) { next ( ) ; return * this ; }
directory_iterator operator ++ ( int ) ;
const char * operator * ( ) { return path ( ) ; }

static const char * separator ( ) { return _fi_sep ; }

friend inline bool operator == ( const directory_iterator & f1 , const directory_iterator & f2 )
{
return ( ( f1 . ref -> hf == 0 ) && ( f2 . ref -> hf == 0 ) ) ;
}


friend inline bool operator != ( const directory_iterator & f1 , const directory_iterator & f2 )
{
return ! ( f1 == f2 ) ;
}

} ;

inline bool operator < ( const directory_iterator & , const directory_iterator & )
{
return false ;
}
#430
}
using boost :: re_detail :: directory_iterator ;
using boost :: re_detail :: file_iterator ;
using boost :: re_detail :: mapfile ;
}
#28 "libs/regex/src/cregex.cpp"
typedef boost :: match_flag_type match_flag_type ;
#38
namespace boost {
#51
namespace {

template < class iterator >
std :: string to_string ( iterator i , iterator j )
{
std :: string s ;
while ( i != j )
{
s . append ( 1 , * i ) ;
++ i ;
}
return s ;
}

inline std :: string to_string ( const char * i , const char * j )
{
return std :: string ( i , j ) ;
}

}
namespace re_detail {

class RegExData
{
public :
enum type
{
type_pc ,
type_pf ,
type_copy
} ;
regex e ;
cmatch m ;

match_results < mapfile :: iterator > fm ;

type t ;
const char * pbase ;

mapfile :: iterator fbase ;

std :: map < int , std :: string , std :: less < int > > strings ;
std :: map < int , std :: ptrdiff_t , std :: less < int > > positions ;
void update ( ) ;
void clean ( ) ;
RegExData ( ) : e ( ) , m ( ) ,

fm ( ) ,

t ( type_copy ) , pbase ( 0 ) ,

fbase ( ) ,

strings ( ) , positions ( ) { }
} ;

void RegExData :: update ( )
{
strings . erase ( strings . begin ( ) , strings . end ( ) ) ;
positions . erase ( positions . begin ( ) , positions . end ( ) ) ;
if ( t == type_pc )
{
for ( unsigned int i = 0 ; i < m . size ( ) ; ++ i )
{
if ( m [ i ] . matched ) strings [ i ] = std :: string ( m [ i ] . first , m [ i ] . second ) ;
positions [ i ] = m [ i ] . matched ? m [ i ] . first - pbase : - 1 ;
}
}

else
{
for ( unsigned int i = 0 ; i < fm . size ( ) ; ++ i )
{
if ( fm [ i ] . matched ) strings [ i ] = to_string ( fm [ i ] . first , fm [ i ] . second ) ;
positions [ i ] = fm [ i ] . matched ? fm [ i ] . first - fbase : - 1 ;
}
}

t = type_copy ;
}

void RegExData :: clean ( )
{

fbase = mapfile :: iterator ( ) ;
fm = match_results < mapfile :: iterator > ( ) ;

}

}

RegEx :: RegEx ( )
{
pdata = new re_detail :: RegExData ( ) ;
}

RegEx :: RegEx ( const RegEx & o )
{
pdata = new re_detail :: RegExData ( * ( o . pdata ) ) ;
}

RegEx :: ~ RegEx ( )
{
delete pdata ;
}

RegEx :: RegEx ( const char * c , bool icase )
{
pdata = new re_detail :: RegExData ( ) ;
SetExpression ( c , icase ) ;
}

RegEx :: RegEx ( const std :: string & s , bool icase )
{
pdata = new re_detail :: RegExData ( ) ;
SetExpression ( s . c_str ( ) , icase ) ;
}

RegEx & RegEx :: operator = ( const RegEx & o )
{
* pdata = * ( o . pdata ) ;
return * this ;
}

RegEx & RegEx :: operator = ( const char * p )
{
SetExpression ( p , false ) ;
return * this ;
}

unsigned int RegEx :: SetExpression ( const char * p , bool icase )
{
boost :: uint_fast32_t f = icase ? regex :: normal | regex :: icase : regex :: normal ;
return pdata -> e . set_expression ( p , f ) ;
}

unsigned int RegEx :: error_code ( ) const
{
return pdata -> e . error_code ( ) ;
}


std :: string RegEx :: Expression ( ) const
{
return pdata -> e . expression ( ) ;
}




bool RegEx :: Match ( const char * p , match_flag_type flags )
{
pdata -> t = re_detail :: RegExData :: type_pc ;
pdata -> pbase = p ;
const char * end = p ;
while ( * end ) ++ end ;

if ( regex_match ( p , end , pdata -> m , pdata -> e , flags ) )
{
pdata -> update ( ) ;
return true ;
}
return false ;
}

bool RegEx :: Search ( const char * p , match_flag_type flags )
{
pdata -> t = re_detail :: RegExData :: type_pc ;
pdata -> pbase = p ;
const char * end = p ;
while ( * end ) ++ end ;

if ( regex_search ( p , end , pdata -> m , pdata -> e , flags ) )
{
pdata -> update ( ) ;
return true ;
}
return false ;
}
namespace re_detail {
struct pred1
{
GrepCallback cb ;
RegEx * pe ;
pred1 ( GrepCallback c , RegEx * i ) : cb ( c ) , pe ( i ) { }
bool operator ( ) ( const cmatch & m )
{
pe -> pdata -> m = m ;
return cb ( * pe ) ;
}
} ;
}
unsigned int RegEx :: Grep ( GrepCallback cb , const char * p , match_flag_type flags )
{
pdata -> t = re_detail :: RegExData :: type_pc ;
pdata -> pbase = p ;
const char * end = p ;
while ( * end ) ++ end ;

unsigned int result = regex_grep ( re_detail :: pred1 ( cb , this ) , p , end , pdata -> e , flags ) ;
if ( result )
pdata -> update ( ) ;
return result ;
}
namespace re_detail {
struct pred2
{
std :: vector < std :: string > & v ;
RegEx * pe ;
pred2 ( std :: vector < std :: string > & o , RegEx * e ) : v ( o ) , pe ( e ) { }
bool operator ( ) ( const cmatch & m )
{
pe -> pdata -> m = m ;
v . push_back ( std :: string ( m [ 0 ] . first , m [ 0 ] . second ) ) ;
return true ;
}
private :
pred2 & operator = ( const pred2 & ) ;
} ;
}

unsigned int RegEx :: Grep ( std :: vector < std :: string > & v , const char * p , match_flag_type flags )
{
pdata -> t = re_detail :: RegExData :: type_pc ;
pdata -> pbase = p ;
const char * end = p ;
while ( * end ) ++ end ;

unsigned int result = regex_grep ( re_detail :: pred2 ( v , this ) , p , end , pdata -> e , flags ) ;
if ( result )
pdata -> update ( ) ;
return result ;
}
namespace re_detail {
struct pred3
{
std :: vector < std :: size_t > & v ;
const char * base ;
RegEx * pe ;
pred3 ( std :: vector < std :: size_t > & o , const char * pb , RegEx * p ) : v ( o ) , base ( pb ) , pe ( p ) { }
bool operator ( ) ( const cmatch & m )
{
pe -> pdata -> m = m ;
v . push_back ( static_cast < std :: size_t > ( m [ 0 ] . first - base ) ) ;
return true ;
}
private :
pred3 & operator = ( const pred3 & ) ;
} ;
}
unsigned int RegEx :: Grep ( std :: vector < std :: size_t > & v , const char * p , match_flag_type flags )
{
pdata -> t = re_detail :: RegExData :: type_pc ;
pdata -> pbase = p ;
const char * end = p ;
while ( * end ) ++ end ;

unsigned int result = regex_grep ( re_detail :: pred3 ( v , p , this ) , p , end , pdata -> e , flags ) ;
if ( result )
pdata -> update ( ) ;
return result ;
}

namespace re_detail {
struct pred4
{
GrepFileCallback cb ;
RegEx * pe ;
const char * file ;
bool ok ;
pred4 ( GrepFileCallback c , RegEx * i , const char * f ) : cb ( c ) , pe ( i ) , file ( f ) , ok ( true ) { }
bool operator ( ) ( const match_results < mapfile :: iterator > & m )
{
pe -> pdata -> t = RegExData :: type_pf ;
pe -> pdata -> fm = m ;
pe -> pdata -> update ( ) ;
ok = cb ( file , * pe ) ;
return ok ;
}
} ;
}
namespace {
void BuildFileList ( std :: list < std :: string > * pl , const char * files , bool recurse )
{
file_iterator start ( files ) ;
file_iterator end ;
if ( recurse )
{

char buf [ 256 ] ;
re_detail :: overflow_error_if_not_zero ( re_detail :: strcpy_s ( buf , 256 , start . root ( ) ) ) ;
if ( * buf == 0 )
{
re_detail :: overflow_error_if_not_zero ( re_detail :: strcpy_s ( buf , 256 , "." ) ) ;
re_detail :: overflow_error_if_not_zero ( re_detail :: strcat_s ( buf , 256 , directory_iterator :: separator ( ) ) ) ;
re_detail :: overflow_error_if_not_zero ( re_detail :: strcat_s ( buf , 256 , "*" ) ) ;
}
else
{
re_detail :: overflow_error_if_not_zero ( re_detail :: strcat_s ( buf , 256 , directory_iterator :: separator ( ) ) ) ;
re_detail :: overflow_error_if_not_zero ( re_detail :: strcat_s ( buf , 256 , "*" ) ) ;
}
directory_iterator dstart ( buf ) ;
directory_iterator dend ;


const char * ptr = files ;
while ( * ptr ) ++ ptr ;
while ( ( ptr != files ) && ( * ptr != * directory_iterator :: separator ( ) ) && ( * ptr != '/' ) ) -- ptr ;
if ( ptr != files ) ++ ptr ;

while ( dstart != dend )
{

if ( std :: strlen ( dstart . path ( ) ) + std :: strlen ( directory_iterator :: separator ( ) ) + std :: strlen ( ptr )
#365
>= 256 )
{

++ dstart ;
continue ;
}



int r = ( std :: sprintf ) ( buf , "%s%s%s" , dstart . path ( ) , directory_iterator :: separator ( ) , ptr ) ;

if ( r < 0 )
{

++ dstart ;
continue ;
}
BuildFileList ( pl , buf , recurse ) ;
++ dstart ;
}
}
while ( start != end )
{
pl -> push_back ( * start ) ;
++ start ;
}
}
}

unsigned int RegEx :: GrepFiles ( GrepFileCallback cb , const char * files , bool recurse , match_flag_type flags )
{
unsigned int result = 0 ;
std :: list < std :: string > file_list ;
BuildFileList ( & file_list , files , recurse ) ;
std :: list < std :: string > :: iterator start , end ;
start = file_list . begin ( ) ;
end = file_list . end ( ) ;

while ( start != end )
{
mapfile map ( ( * start ) . c_str ( ) ) ;
pdata -> t = re_detail :: RegExData :: type_pf ;
pdata -> fbase = map . begin ( ) ;
re_detail :: pred4 pred ( cb , this , ( * start ) . c_str ( ) ) ;
int r = regex_grep ( pred , map . begin ( ) , map . end ( ) , pdata -> e , flags ) ;
result += r ;
++ start ;
pdata -> clean ( ) ;
if ( pred . ok == false )
return result ;
}

return result ;
}


unsigned int RegEx :: FindFiles ( FindFilesCallback cb , const char * files , bool recurse , match_flag_type flags )
{
unsigned int result = 0 ;
std :: list < std :: string > file_list ;
BuildFileList ( & file_list , files , recurse ) ;
std :: list < std :: string > :: iterator start , end ;
start = file_list . begin ( ) ;
end = file_list . end ( ) ;

while ( start != end )
{
mapfile map ( ( * start ) . c_str ( ) ) ;
pdata -> t = re_detail :: RegExData :: type_pf ;
pdata -> fbase = map . begin ( ) ;

if ( regex_search ( map . begin ( ) , map . end ( ) , pdata -> fm , pdata -> e , flags ) )
{
++ result ;
if ( false == cb ( ( * start ) . c_str ( ) ) )
return result ;
}

++ start ;

}

return result ;
}
#455
std :: string RegEx :: Merge ( const std :: string & in , const std :: string & fmt ,
bool copy , match_flag_type flags )
{
std :: string result ;
re_detail :: string_out_iterator < std :: string > i ( result ) ;
if ( ! copy ) flags |= format_no_copy ;
regex_replace ( i , in . begin ( ) , in . end ( ) , pdata -> e , fmt . c_str ( ) , flags ) ;
return result ;
}

std :: string RegEx :: Merge ( const char * in , const char * fmt ,
bool copy , match_flag_type flags )
{
std :: string result ;
if ( ! copy ) flags |= format_no_copy ;
re_detail :: string_out_iterator < std :: string > i ( result ) ;
regex_replace ( i , in , in + std :: strlen ( in ) , pdata -> e , fmt , flags ) ;
return result ;
}

std :: size_t RegEx :: Split ( std :: vector < std :: string > & v ,
std :: string & s ,
match_flag_type flags ,
unsigned max_count )
{
return regex_split ( std :: back_inserter ( v ) , s , pdata -> e , flags , max_count ) ;
}
#488
std :: size_t RegEx :: Position ( int i ) const
{
switch ( pdata -> t )
{
case re_detail :: RegExData :: type_pc :
return pdata -> m [ i ] . matched ? pdata -> m [ i ] . first - pdata -> pbase : RegEx :: npos ;

case re_detail :: RegExData :: type_pf :
return pdata -> fm [ i ] . matched ? pdata -> fm [ i ] . first - pdata -> fbase : RegEx :: npos ;

case re_detail :: RegExData :: type_copy :
{
std :: map < int , std :: ptrdiff_t , std :: less < int > > :: iterator pos = pdata -> positions . find ( i ) ;
if ( pos == pdata -> positions . end ( ) )
return RegEx :: npos ;
return ( * pos ) . second ;
}
}
return RegEx :: npos ;
}

std :: size_t RegEx :: Marks ( ) const
{
return pdata -> e . mark_count ( ) ;
}


std :: size_t RegEx :: Length ( int i ) const
{
switch ( pdata -> t )
{
case re_detail :: RegExData :: type_pc :
return pdata -> m [ i ] . matched ? pdata -> m [ i ] . second - pdata -> m [ i ] . first : RegEx :: npos ;

case re_detail :: RegExData :: type_pf :
return pdata -> fm [ i ] . matched ? pdata -> fm [ i ] . second - pdata -> fm [ i ] . first : RegEx :: npos ;

case re_detail :: RegExData :: type_copy :
{
std :: map < int , std :: string , std :: less < int > > :: iterator pos = pdata -> strings . find ( i ) ;
if ( pos == pdata -> strings . end ( ) )
return RegEx :: npos ;
return ( * pos ) . second . size ( ) ;
}
}
return RegEx :: npos ;
}

bool RegEx :: Matched ( int i ) const
{
switch ( pdata -> t )
{
case re_detail :: RegExData :: type_pc :
return pdata -> m [ i ] . matched ;

case re_detail :: RegExData :: type_pf :
return pdata -> fm [ i ] . matched ;

case re_detail :: RegExData :: type_copy :
{
std :: map < int , std :: string , std :: less < int > > :: iterator pos = pdata -> strings . find ( i ) ;
if ( pos == pdata -> strings . end ( ) )
return false ;
return true ;
}
}
return false ;
}


std :: string RegEx :: What ( int i ) const
{
std :: string result ;
switch ( pdata -> t )
{
case re_detail :: RegExData :: type_pc :
if ( pdata -> m [ i ] . matched )
result . assign ( pdata -> m [ i ] . first , pdata -> m [ i ] . second ) ;
break ;
case re_detail :: RegExData :: type_pf :
if ( pdata -> m [ i ] . matched )
result . assign ( to_string ( pdata -> m [ i ] . first , pdata -> m [ i ] . second ) ) ;
break ;
case re_detail :: RegExData :: type_copy :
{
std :: map < int , std :: string , std :: less < int > > :: iterator pos = pdata -> strings . find ( i ) ;
if ( pos != pdata -> strings . end ( ) )
result = ( * pos ) . second ;
break ;
}
}
return result ;
}

const std :: size_t RegEx :: npos = ~ static_cast < std :: size_t > ( 0 ) ;

}