#! /bin/sh

# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 2.12 
# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.

# Defaults:
ac_help=
ac_default_prefix=/usr/local
# Any additions from configure.in:
ac_help="$ac_help
--enable-extension=<ext>"
ac_help="$ac_help
--enable-namespaces Use namespaces (default if posssible)
--disable-namespaces Don't use namespaces support"
ac_help="$ac_help
--enable-exceptions Use exceptions support (default if posssible)
 --disable-exceptions Don't use exceptions support"
ac_help="$ac_help
--enable-relops Separate rel_ops namespace for relational operators (default if posssible)
--disable-relops No separate rel_ops namespace for relational operators"
ac_help="$ac_help
--enable-new-style-headers Use new-style headers (default)
--disable-new-style-headers Don't use new-style headers"
ac_help="$ac_help
--enable-new-iostreams Use new iostreams (default)
--disable-new-iostreams Don't use new iostreams"
ac_help="$ac_help
--enable-sgi-allocators : set default parameter to SGI-style default alloc, not allocator<T>
 --disable-sgi-allocators : use allocator<T> if possible"
ac_help="$ac_help
--enable-malloc : set default alloc to malloc-based allocator ( malloc_alloc_template<instance_no>, alloc.h )
--disable-malloc : choose (default) sgi node allocator (__alloc<threads,no>  alloc.h )"
ac_help="$ac_help
--enable-newalloc : set default alloc to new-based allocator ( new_alloc, alloc.h )
--disable-newalloc : choose (default) sgi allocator (__alloc<threads,no>  alloc.h )"
ac_help="$ac_help
--enable-defalloc : make HP-style defalloc.h included in alloc.h )
--disable-defalloc : leave defalloc.h alone"
ac_help="$ac_help
--enable-debugalloc : use debug versions of allocators
--disable-debugalloc : not using debug allocators"
ac_help="$ac_help
--enable-abbrevs : use abbreviated class names internally for linker benefit (don't affect interface)
--disable-abbrevs : don't use abbreviated names"

# Initialize some variables set by options.
# The variables have the same names as the options, with
# dashes changed to underlines.
build=NONE
cache_file=./config.cache
exec_prefix=NONE
host=NONE
no_create=
nonopt=NONE
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
target=NONE
verbose=
x_includes=NONE
x_libraries=NONE
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datadir='${prefix}/share'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
libdir='${exec_prefix}/lib'
includedir='${prefix}/include'
oldincludedir='/usr/include'
infodir='${prefix}/info'
mandir='${prefix}/man'

# Initialize some other variables.
subdirs=
MFLAGS= MAKEFLAGS=
# Maximum number of lines to put in a shell here document.
ac_max_here_lines=12

ac_prev=
for ac_option
do

  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval "$ac_prev=\$ac_option"
    ac_prev=
    continue
  fi

  case "$ac_option" in
  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
  *) ac_optarg= ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case "$ac_option" in

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
    bindir="$ac_optarg" ;;

  -build | --build | --buil | --bui | --bu)
    ac_prev=build ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
    build="$ac_optarg" ;;

  -cache-file | --cache-file | --cache-fil | --cache-fi \
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
    ac_prev=cache_file ;;
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
    cache_file="$ac_optarg" ;;

  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
  | --da=*)
    datadir="$ac_optarg" ;;

  -disable-* | --disable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    eval "enable_${ac_feature}=no" ;;

  -enable-* | --enable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "enable_${ac_feature}='$ac_optarg'" ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix="$ac_optarg" ;;

  -gas | --gas | --ga | --g)
    # Obsolete; use --with-gas.
    with_gas=yes ;;

  -help | --help | --hel | --he)
    # Omit some internal or obsolete options to make the list less imposing.
    # This message is too long to be a string in the A/UX 3.1 sh.
    cat << EOF
Usage: configure [options] [host]
Options: [defaults in brackets after descriptions]
Configuration:
  --cache-file=FILE       cache test results in FILE
  --help                  print this message
  --no-create             do not create output files
  --quiet, --silent       do not print \`checking...' messages
  --version               print the version of autoconf that created configure
Directory and file names:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [same as prefix]
  --bindir=DIR            user executables in DIR [EPREFIX/bin]
  --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
  --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
  --datadir=DIR           read-only architecture-independent data in DIR
                          [PREFIX/share]
  --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data in DIR
                          [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
  --includedir=DIR        C header files in DIR [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
  --infodir=DIR           info documentation in DIR [PREFIX/info]
  --mandir=DIR            man documentation in DIR [PREFIX/man]
  --srcdir=DIR            find the sources in DIR [configure dir or ..]
  --program-prefix=PREFIX prepend PREFIX to installed program names
  --program-suffix=SUFFIX append SUFFIX to installed program names
  --program-transform-name=PROGRAM
                          run sed PROGRAM on installed program names
EOF
    cat << EOF
Host type:
  --build=BUILD           configure for building on BUILD [BUILD=HOST]
  --host=HOST             configure for HOST [guessed]
  --target=TARGET         configure for TARGET [TARGET=HOST]
Features and packages:
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --x-includes=DIR        X include files are in DIR
  --x-libraries=DIR       X library files are in DIR
EOF
    if test -n "$ac_help"; then
      echo "--enable and --with options recognized:$ac_help"
    fi
    exit 0 ;;

  -host | --host | --hos | --ho)
    ac_prev=host ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host="$ac_optarg" ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
  | --includ=* | --inclu=* | --incl=* | --inc=*)
    includedir="$ac_optarg" ;;

  -infodir | --infodir | --infodi | --infod | --info | --inf)
    ac_prev=infodir ;;
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
    infodir="$ac_optarg" ;;

  -libdir | --libdir | --libdi | --libd)
    ac_prev=libdir ;;
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
    libdir="$ac_optarg" ;;

  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
  | --libexe | --libex | --libe)
    ac_prev=libexecdir ;;
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
  | --libexe=* | --libex=* | --libe=*)
    libexecdir="$ac_optarg" ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst \
  | --locals | --local | --loca | --loc | --lo)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
    localstatedir="$ac_optarg" ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
    ac_prev=mandir ;;
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
    mandir="$ac_optarg" ;;

  -nfp | --nfp | --nf)
    # Obsolete; use --without-fp.
    with_fp=no ;;

  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c)
    no_create=yes ;;

  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
    no_recursion=yes ;;

  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
  | --oldin | --oldi | --old | --ol | --o)
    ac_prev=oldincludedir ;;
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
    oldincludedir="$ac_optarg" ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix="$ac_optarg" ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix="$ac_optarg" ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix="$ac_optarg" ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name="$ac_optarg" ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir="$ac_optarg" ;;

  -sharedstatedir | --sharedstatedir | --sharedstatedi \
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
  | --sharedst | --shareds | --shared | --share | --shar \
  | --sha | --sh)
    ac_prev=sharedstatedir ;;
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
  | --sha=* | --sh=*)
    sharedstatedir="$ac_optarg" ;;

  -site | --site | --sit)
    ac_prev=site ;;
  -site=* | --site=* | --sit=*)
    site="$ac_optarg" ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir="$ac_optarg" ;;

  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
  | --syscon | --sysco | --sysc | --sys | --sy)
    ac_prev=sysconfdir ;;
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
    sysconfdir="$ac_optarg" ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target="$ac_optarg" ;;

  -v | -verbose | --verbose | --verbos | --verbo | --verb)
    verbose=yes ;;

  -version | --version | --versio | --versi | --vers)
    echo "configure generated by autoconf version 2.12"
    exit 0 ;;

  -with-* | --with-*)
    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "with_${ac_package}='$ac_optarg'" ;;

  -without-* | --without-*)
    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    eval "with_${ac_package}=no" ;;

  --x)
    # Obsolete; use --with-x.
    with_x=yes ;;

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes="$ac_optarg" ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries="$ac_optarg" ;;

  -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
    ;;

  *)
    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
      echo "configure: warning: $ac_option: invalid host type" 1>&2
    fi
    if test "x$nonopt" != xNONE; then
      { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
    fi
    nonopt="$ac_option"
    ;;

  esac
done

if test -n "$ac_prev"; then
  { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
fi

trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15

# File descriptor usage:
# 0 standard input
# 1 file creation
# 2 errors and warnings
# 3 some systems may open it to /dev/tty
# 4 used on the Kubota Titan
# 6 checking for... messages and results
# 5 compiler messages saved in config.log
if test "$silent" = yes; then
  exec 6>/dev/null
else
  exec 6>&1
fi
exec 5>./config.log

echo "\
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
" 1>&5

# Strip out --no-create and --no-recursion so they do not pile up.
# Also quote any args containing shell metacharacters.
ac_configure_args=
for ac_arg
do
  case "$ac_arg" in
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c) ;;
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
  *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
  esac
done

# NLS nuisances.
# Only set these to C if already set.  These must not be set unconditionally
# because not all systems understand e.g. LANG=C (notably SCO).
# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
# Non-C LC_CTYPE values break the ctype check.
if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -rf conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h

# A filename unique to this package, relative to the directory that
# configure is in, which we can look for to find out if srcdir is correct.
ac_unique_file=stlconf.h.in

# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then its parent.
  ac_prog=$0
  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
  srcdir=$ac_confdir
  if test ! -r $srcdir/$ac_unique_file; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r $srcdir/$ac_unique_file; then
  if test "$ac_srcdir_defaulted" = yes; then
    { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
  else
    { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
  fi
fi
srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`

# Prefer explicitly selected file to automatically selected ones.
if test -z "$CONFIG_SITE"; then
  if test "x$prefix" != xNONE; then
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
  else
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
  fi
fi
for ac_site_file in $CONFIG_SITE; do
  if test -r "$ac_site_file"; then
    echo "loading site script $ac_site_file"
    . "$ac_site_file"
  fi
done


ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
    ac_n= ac_c='
' ac_t='	'
  else
    ac_n=-n ac_c= ac_t=
  fi
else
  ac_n= ac_c='\c' ac_t=
fi




echo "$ac_t""*** $0: STLport configuration utility ***" 1>&6
if test "${CXXFLAGS}" = ""; then 
echo "$ac_t""* Note: for best reliability - try \"CXXFLAGS=-treat_warnings_as_errors\" $0 " 1>&6
echo "$ac_t""* Please don't forget specifying typical CXXFLAGS you'll be using - " 1>&6 
echo "$ac_t""* such as that enabling exceptions handling" 1>&6
fi
echo "$ac_t""Please stand by while exploring compiler capabilities..." 1>&6
echo "$ac_t""Be patient - that may take a while..." 1>&6
echo "$ac_t""***" 1>&6

# utility function
check_warning () {
    warn_str=`tail -1 config.log | egrep -i "arning|\(W\)"`
    if test "$warn_str" = ""; then
      return 0
    else
     return 1
    fi
}


# Check whether --enable-extension or --disable-extension was given.
if test "${enable_extension+set}" = set; then
  enableval="$enable_extension"
  
case "$enableval" in
	no) echo "$ac_t""Info :.cpp used as extension for tests" 1>&6 
	    ac_ext=cpp 
      	;;
	 *) echo "$ac_t""Argument : .$enableval used as extension" 1>&6 
	ac_ext=$enableval
esac

else
  echo "$ac_t""Info : .cpp used as extension for tests" 1>&6 
	ac_ext=cpp


fi


# Save that, as it is being redefined several times 
use_ac_ext=$ac_ext

for ac_prog in $CCC c++ g++ gcc CC cxx cc++
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:601: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CXX"; then
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_CXX="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CXX="$ac_cv_prog_CXX"
if test -n "$CXX"; then
  echo "$ac_t""$CXX" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

test -n "$CXX" && break
done
test -n "$CXX" || CXX="gcc"


echo $ac_n "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works""... $ac_c" 1>&6
echo "configure:632: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5

ac_ext=C
# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CXX-g++} -o conftest $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cxx_cross

cat > conftest.$ac_ext <<EOF
#line 642 "configure"
#include "confdefs.h"
main(){return(0);}
EOF
if { (eval echo configure:646: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  ac_cv_prog_cxx_works=yes
  # If we can't run a trivial program, we are probably using a cross compiler.
  if (./conftest; exit) 2>/dev/null; then
    ac_cv_prog_cxx_cross=no
  else
    ac_cv_prog_cxx_cross=yes
  fi
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_cv_prog_cxx_works=no
fi
rm -fr conftest*
ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

echo "$ac_t""$ac_cv_prog_cxx_works" 1>&6
if test $ac_cv_prog_cxx_works = no; then
  { echo "configure: error: installation or configuration problem: C++ compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
echo "configure:672: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cxx_cross" 1>&6
cross_compiling=$ac_cv_prog_cxx_cross

echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
echo "configure:677: checking whether we are using GNU C++" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.C <<EOF
#ifdef __GNUC__
  yes;
#endif
EOF
if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:686: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
  ac_cv_prog_gxx=yes
else
  ac_cv_prog_gxx=no
fi
fi

echo "$ac_t""$ac_cv_prog_gxx" 1>&6

if test $ac_cv_prog_gxx = yes; then
  GXX=yes
  ac_test_CXXFLAGS="${CXXFLAGS+set}"
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS=
  echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
echo "configure:701: checking whether ${CXX-g++} accepts -g" >&5
if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  echo 'void f(){}' > conftest.cc
if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
  ac_cv_prog_cxx_g=yes
else
  ac_cv_prog_cxx_g=no
fi
rm -f conftest*

fi

echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
  if test "$ac_test_CXXFLAGS" = set; then
    CXXFLAGS="$ac_save_CXXFLAGS"
  elif test $ac_cv_prog_cxx_g = yes; then
    CXXFLAGS="-g -O2"
  else
    CXXFLAGS="-O2"
  fi
else
  GXX=
  test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
fi

ac_ext=$use_ac_ext

ac_ext=C
# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CXX-g++} -o conftest $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cxx_cross

ac_ext=$use_ac_ext

echo $ac_n "checking size of int""... $ac_c" 1>&6
echo "configure:740: checking size of int" >&5
if eval "test \"`echo '$''{'ac_cv_sizeof_int'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  ac_cv_sizeof_int=4
else
  cat > conftest.$ac_ext <<EOF
#line 748 "configure"
#include "confdefs.h"
#ifdef __cplusplus
extern "C" void exit(int);
#endif
#include <stdio.h>
main()
{
  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(int));
  exit(0);
}
EOF
if { (eval echo configure:762: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null
then
  ac_cv_sizeof_int=`cat conftestval`
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -fr conftest*
  ac_cv_sizeof_int=0
fi
rm -fr conftest*
fi

fi
echo "$ac_t""$ac_cv_sizeof_int" 1>&6
cat >> confdefs.h <<EOF
#define SIZEOF_INT $ac_cv_sizeof_int
EOF


ac_ext=$use_ac_ext

if test "$ac_cv_sizeof_int" = "4"; then
  cat >> confdefs.h <<EOF
#define _STLP_UINT32_T unsigned int
EOF

else
  echo $ac_n "checking size of long""... $ac_c" 1>&6
echo "configure:790: checking size of long" >&5
if eval "test \"`echo '$''{'ac_cv_sizeof_long'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  ac_cv_sizeof_long=4
else
  cat > conftest.$ac_ext <<EOF
#line 798 "configure"
#include "confdefs.h"
#ifdef __cplusplus
extern "C" void exit(int);
#endif
#include <stdio.h>
main()
{
  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(long));
  exit(0);
}
EOF
if { (eval echo configure:812: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null
then
  ac_cv_sizeof_long=`cat conftestval`
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -fr conftest*
  ac_cv_sizeof_long=0
fi
rm -fr conftest*
fi

fi
echo "$ac_t""$ac_cv_sizeof_long" 1>&6
cat >> confdefs.h <<EOF
#define SIZEOF_LONG $ac_cv_sizeof_long
EOF


  ac_ext=$use_ac_ext
  if test "$ac_cv_sizeof_long" = "4"; then
    cat >> confdefs.h <<EOF
#define _STLP_UINT32_T unsigned long
EOF

  else
      echo $ac_n "checking size of short""... $ac_c" 1>&6
echo "configure:839: checking size of short" >&5
if eval "test \"`echo '$''{'ac_cv_sizeof_short'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  ac_cv_sizeof_short=4
else
  cat > conftest.$ac_ext <<EOF
#line 847 "configure"
#include "confdefs.h"
#ifdef __cplusplus
extern "C" void exit(int);
#endif
#include <stdio.h>
main()
{
  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(short));
  exit(0);
}
EOF
if { (eval echo configure:861: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null
then
  ac_cv_sizeof_short=`cat conftestval`
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -fr conftest*
  ac_cv_sizeof_short=0
fi
rm -fr conftest*
fi

fi
echo "$ac_t""$ac_cv_sizeof_short" 1>&6
cat >> confdefs.h <<EOF
#define SIZEOF_SHORT $ac_cv_sizeof_short
EOF


    if test "$ac_cv_sizeof_short" = "4"; then
      cat >> confdefs.h <<EOF
#define _STLP_UINT32_T unsigned short
EOF

    else
      { echo "configure: error: Cannot find any 32-bit integer type for your compiler" 1>&2; exit 1; }
    fi
  ac_ext=$use_ac_ext
  fi
fi
ac_ext=$use_ac_ext


if test "$ac_cv_c_cross" = "yes"; then
  CXXFLAGS="${CXXFLAGS} -c"
fi

ac_ext=$use_ac_ext

echo $ac_n "checking for basic STL compatibility""... $ac_c" 1>&6
echo "configure:901: checking for basic STL compatibility" >&5
cat > conftest.$ac_ext <<EOF
#line 903 "configure"
#include "confdefs.h"

template <class Arg1, class Arg2, class Result>
struct binary_function {
    typedef Arg1 first_argument_type;
    typedef Arg2 second_argument_type;
    typedef Result result_type;
};      
template <class T>
struct plus : public binary_function<T, T, T> {
    T operator()(const T& x, const T& y) const;
};

template <class T>
T plus<T>::operator()(const T& x, const T& y) const { return x + y; }
plus<int> p;

int main() {

; return 0; }
EOF
if { (eval echo configure:925: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_compat="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  { echo "configure: error: Your compiler won't be able to compile this implementation. Sorry." 1>&2; exit 1; } 
 ac_cv_compat="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_compat" 1>&6

echo $ac_n "checking for partial specialization syntax""... $ac_c" 1>&6
echo "configure:940: checking for partial specialization syntax" >&5
cat > conftest.$ac_ext <<EOF
#line 942 "configure"
#include "confdefs.h"

     template <class T> class fs_foo {};
     template <> class fs_foo<int> {};
int main() {
 fs_foo<int> i;
; return 0; }
EOF
if { (eval echo configure:951: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
    _FULL_SPEC="template <>" ac_cv_spec_syntax="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
    cat >> confdefs.h <<\EOF
#define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1
EOF
 ac_cv_spec_syntax="no" _FULL_SPEC=""
fi
rm -f conftest*
echo "$ac_t""$ac_cv_spec_syntax" 1>&6

echo $ac_n "checking for bool keyword""... $ac_c" 1>&6
echo "configure:967: checking for bool keyword" >&5
cat > conftest.$ac_ext <<EOF
#line 969 "configure"
#include "confdefs.h"
bool b_foo() { return true; }
int main() {
(void)b_foo();
; return 0; }
EOF
if { (eval echo configure:976: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_bool="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_BOOL 1
EOF
 ac_cv_bool="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_bool" 1>&6
if test "$ac_cv_bool" = "no"; then
  echo $ac_n "checking for yvals.h header""... $ac_c" 1>&6
echo "configure:992: checking for yvals.h header" >&5
  cat > conftest.$ac_ext <<EOF
#line 994 "configure"
#include "confdefs.h"
#include <yvals.h> 
    extern bool aaa=true;
   
int main() {

; return 0; }
EOF
if { (eval echo configure:1003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_YVALS_H 1
EOF
 echo "$ac_t""yes" 1>&6 
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  
  echo "$ac_t""no" 1>&6
  echo $ac_n "checking whether bool is reserved word""... $ac_c" 1>&6
echo "configure:1016: checking whether bool is reserved word" >&5
  cat > conftest.$ac_ext <<EOF
#line 1018 "configure"
#include "confdefs.h"
typedef int bool;
int main() {

; return 0; }
EOF
if { (eval echo configure:1025: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_bool_reserved="no"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_DONT_USE_BOOL_TYPEDEF 1
EOF
 ac_cv_bool_reserved="yes"
fi
rm -f conftest*
  echo "$ac_t""$ac_cv_bool_reserved" 1>&6
  
fi
rm -f conftest*
fi

echo $ac_n "checking for wchar_t type""... $ac_c" 1>&6
echo "configure:1045: checking for wchar_t type" >&5
cat > conftest.$ac_ext <<EOF
#line 1047 "configure"
#include "confdefs.h"
 #include <wchar.h>
      wchar_t wc_foo() { return 'a'; }
int main() {
(void)wc_foo();
; return 0; }
EOF
if { (eval echo configure:1055: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_wchar="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_WCHAR_T 1
EOF
 ac_cv_wchar="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_wchar" 1>&6

echo $ac_n "checking if wchar_t is unsigned short""... $ac_c" 1>&6
echo "configure:1071: checking if wchar_t is unsigned short" >&5
cat > conftest.$ac_ext <<EOF
#line 1073 "configure"
#include "confdefs.h"

     # include <wchar.h>
     template <class T> struct foo {};
     $_FULL_SPEC struct foo <wchar_t> {};
     typedef unsigned short u__short;
     $_FULL_SPEC struct foo <u__short> {};
     foo<wchar_t> f1;
     foo<u__short> f2;
	
int main() {

; return 0; }
EOF
if { (eval echo configure:1088: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_wchar_short="no"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_WCHAR_T_IS_USHORT 1
EOF
 ac_cv_wchar_short="yes"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_wchar_short" 1>&6

echo $ac_n "checking for long long type""... $ac_c" 1>&6
echo "configure:1104: checking for long long type" >&5
cat > conftest.$ac_ext <<EOF
#line 1106 "configure"
#include "confdefs.h"
long long ll_foo() { return 0; }
int main() {
(void)ll_foo();
; return 0; }
EOF
if { (eval echo configure:1113: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_LONG_LONG 1
EOF
 ac_cv_long_long="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  ac_cv_long_long="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_long_long" 1>&6

echo $ac_n "checking for long double type""... $ac_c" 1>&6
echo "configure:1129: checking for long double type" >&5
cat > conftest.$ac_ext <<EOF
#line 1131 "configure"
#include "confdefs.h"
long double ld_foo() { return 0; }
int main() {
(void)ld_foo();
; return 0; }
EOF
if { (eval echo configure:1138: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_long_double="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_LONG_DOUBLE 1
EOF
 ac_cv_long_double="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_long_double" 1>&6

echo $ac_n "checking for typename keyword""... $ac_c" 1>&6
echo "configure:1154: checking for typename keyword" >&5
cat > conftest.$ac_ext <<EOF
#line 1156 "configure"
#include "confdefs.h"

template <class T1, class T2>
struct pair {
    typedef T1 first_type;
    typedef T2 second_type;
};

template <class Arg, class Result>
struct unary_function {
    typedef Arg argument_type;
    typedef Result result_type;
};

template <class Pair>
struct select2nd : public unary_function<Pair, typename Pair::second_type> {
  typedef typename Pair::first_type ignored_type;
  const typename Pair::second_type& operator()(const typename Pair::second_type& x,
						const ignored_type& ) const
  {
    return x;
  }
  
};
    
int main() {
 
	typedef pair<int,int> tn_p;
	select2nd< tn_p > tn_s;
	(void)tn_s(1,5);
    
; return 0; }
EOF
if { (eval echo configure:1190: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  __TYPENAME="typename" 
     ac_cv_typename="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  __TYPENAME="" 
     cat >> confdefs.h <<\EOF
#define _STLP_NEED_TYPENAME 1
EOF

     ac_cv_typename="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_typename" 1>&6

echo $ac_n "checking for explicit keyword""... $ac_c" 1>&6
echo "configure:1209: checking for explicit keyword" >&5
cat > conftest.$ac_ext <<EOF
#line 1211 "configure"
#include "confdefs.h"
struct expl_Class { int a; explicit expl_Class(int t): a(t) {} };
    expl_Class c(1);
    
int main() {

; return 0; }
EOF
if { (eval echo configure:1220: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_explicit="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_EXPLICIT 1
EOF
 ac_cv_explicit="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_explicit" 1>&6

echo $ac_n "checking for mutable keyword""... $ac_c" 1>&6
echo "configure:1236: checking for mutable keyword" >&5
cat > conftest.$ac_ext <<EOF
#line 1238 "configure"
#include "confdefs.h"
struct mut_Class { mutable int a; void update() const { a=0; }  };
    mut_Class c;
    
int main() {
c.update()
; return 0; }
EOF
if { (eval echo configure:1247: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_mutable="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NEED_MUTABLE 1
EOF
 ac_cv_mutable="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_mutable" 1>&6

echo $ac_n "checking for new style casts""... $ac_c" 1>&6
echo "configure:1263: checking for new style casts" >&5
cat > conftest.$ac_ext <<EOF
#line 1265 "configure"
#include "confdefs.h"
struct ncast_Class { 
	int a; void update(int* i) { *i=a; }  };
    ncast_Class c;
    
int main() {

  const int a(5);
  c.update(const_cast<int*>(&a))
    
; return 0; }
EOF
if { (eval echo configure:1278: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_new_cast="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_NEW_STYLE_CASTS 1
EOF
 ac_cv_new_cast="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_new_cast" 1>&6

echo $ac_n "checking for new-style C library headers""... $ac_c" 1>&6
echo "configure:1294: checking for new-style C library headers" >&5
cat > conftest.$ac_ext <<EOF
#line 1296 "configure"
#include "confdefs.h"

     #include <cctype>
     #include <cstddef>
     #include <cstdio>
     #include <cstdlib>
     #include <cstring>
     #include <cassert>
     #include <climits>
     #ifndef _STLP_NO_WCHAR_T
     #include <cwchar>
     #endif
       
int main() {

; return 0; }
EOF
if { (eval echo configure:1314: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_newheaders="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_HAS_NO_NEW_C_HEADERS 1
EOF
 ac_cv_newheaders="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_newheaders" 1>&6

echo $ac_n "checking for new-style <new> header""... $ac_c" 1>&6
echo "configure:1330: checking for new-style <new> header" >&5
cat > conftest.$ac_ext <<EOF
#line 1332 "configure"
#include "confdefs.h"

     #include <new>
       
int main() {

; return 0; }
EOF
if { (eval echo configure:1341: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_new_new="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_NEW_NEW_HEADER 1
EOF
 ac_cv_new_new="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_new_new" 1>&6


echo $ac_n "checking for member template methods""... $ac_c" 1>&6
echo "configure:1358: checking for member template methods" >&5
cat > conftest.$ac_ext <<EOF
#line 1360 "configure"
#include "confdefs.h"

template <class Result>
struct mt_foo {
    typedef Result result_type;
    template <class Arg> result_type operate(const Arg&) { return Result(); }
};      
mt_foo<int> p;

int main() {

(void)p.operate((char*)"aaa");

; return 0; }
EOF
if { (eval echo configure:1376: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_member_templates="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_MEMBER_TEMPLATES 1
EOF
 ac_cv_member_templates="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_member_templates" 1>&6

echo $ac_n "checking for friend templates""... $ac_c" 1>&6
echo "configure:1393: checking for friend templates" >&5
cat > conftest.$ac_ext <<EOF
#line 1395 "configure"
#include "confdefs.h"


template <class Result2> class foo;

template <class Result>
struct ft_foo {
    typedef Result result_type;
    template <class Result2> friend class foo;
};      
ft_foo<int> p;

int main() {

; return 0; }
EOF
if { (eval echo configure:1412: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_friend_templates="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_FRIEND_TEMPLATES 1
EOF
 ac_cv_friend_templates="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_friend_templates" 1>&6

echo $ac_n "checking for qualified friend templates""... $ac_c" 1>&6
echo "configure:1429: checking for qualified friend templates" >&5
cat > conftest.$ac_ext <<EOF
#line 1431 "configure"
#include "confdefs.h"


${_TEST_STD_BEGIN}

template <class Result2> class foo;

template <class Result>
struct ft_foo {
    typedef Result result_type;
    template <class Result2> friend class $_TEST_STD::foo;
};      
ft_foo<int> p;
${_TEST_STD_END}


int main() {

; return 0; }
EOF
if { (eval echo configure:1452: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_qual_friend_templates="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_QUALIFIED_FRIENDS 1
EOF
 ac_cv_qual_friend_templates="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_qual_friend_templates" 1>&6

echo $ac_n "checking for member template keyword""... $ac_c" 1>&6
echo "configure:1469: checking for member template keyword" >&5
cat > conftest.$ac_ext <<EOF
#line 1471 "configure"
#include "confdefs.h"

template <class Result>
struct nt_foo {
    typedef Result result_type;
    template <class Arg> struct rebind {  typedef nt_foo<Arg> other; };
};

template <class _Tp, class _Allocator>
struct _Traits
{
  typedef typename _Allocator:: template rebind<_Tp> my_rebind; 
  typedef typename my_rebind::other allocator_type;
};

nt_foo<char> p;
_Traits< int, nt_foo<short> > pp;

int main() {

; return 0; }
EOF
if { (eval echo configure:1494: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_member_template_keyword="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
EOF
 ac_cv_member_template_keyword="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_member_template_keyword" 1>&6

if test "$ac_cv_member_template_keyword" = "no"; then
echo $ac_n "checking for member template classes""... $ac_c" 1>&6
echo "configure:1512: checking for member template classes" >&5
cat > conftest.$ac_ext <<EOF
#line 1514 "configure"
#include "confdefs.h"

template <class Result>
struct nt_foo {
    typedef Result result_type;
    template <class Arg> struct rebind {  typedef nt_foo<Arg> other; };
};

template <class _Tp, class _Allocator>
struct _Traits
{
  typedef typename _Allocator::rebind<_Tp> my_rebind; 
  typedef typename my_rebind::other allocator_type;
};

nt_foo<char> p;
_Traits< int, nt_foo<short> > pp;

int main() {

; return 0; }
EOF
if { (eval echo configure:1537: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_member_template_classes="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
EOF
 ac_cv_member_template_classes="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_member_template_classes" 1>&6
fi

echo $ac_n "checking for partial class specialization""... $ac_c" 1>&6
echo "configure:1555: checking for partial class specialization" >&5
cat > conftest.$ac_ext <<EOF
#line 1557 "configure"
#include "confdefs.h"

template <class Arg,class Result>
struct ps_foo {
    typedef Arg argument_type;
    typedef Result result_type;
};   

template<class Result>
struct ps_foo<Result*,Result*> {
	void bar() {}
};

template<class Result>
struct ps_foo<int*,Result> {
	void foo() {}
};

ps_foo<char*, char*> p;
ps_foo<int*, int> p1;

int main() {
p.bar();
 p1.foo();
; return 0; }
EOF
if { (eval echo configure:1584: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_partial_spec="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
EOF
 ac_cv_partial_spec="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_partial_spec" 1>&6

if test "$ac_cv_partial_spec" = yes; then

echo $ac_n "checking if explicit args accepted on constructors of partial specialized classes""... $ac_c" 1>&6
echo "configure:1603: checking if explicit args accepted on constructors of partial specialized classes" >&5
cat > conftest.$ac_ext <<EOF
#line 1605 "configure"
#include "confdefs.h"

template <class Arg,class Result>
struct ps_foo {
    typedef Arg argument_type;
    typedef Result result_type;
};   

template<class Result>
struct ps_foo<Result*,Result*> {
	ps_foo<Result*,Result*>() {}
	void bar() {}
};

template<class Result>
struct ps_foo<int*,Result> {
	ps_foo<int*,Result*>() {}
	void bar() {}

};

ps_foo<char*, char*> p;
ps_foo<int*, int> p1;

int main() {
p.bar();
 p1.foo();
; return 0; }
EOF
if { (eval echo configure:1635: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS 1
EOF
 ac_cv_partial_spec_needs_args="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  ac_cv_partial_spec_needs_args="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_partial_spec_needs_args" 1>&6

fi

if test ac_cv_partial_spec_needs_args=="no"; then

echo $ac_n "checking if explicit args accepted on constructors of explicitly specialized classes""... $ac_c" 1>&6
echo "configure:1656: checking if explicit args accepted on constructors of explicitly specialized classes" >&5
cat > conftest.$ac_ext <<EOF
#line 1658 "configure"
#include "confdefs.h"

template <class Arg,class Result>
struct ps_foo {
    typedef Arg argument_type;
    typedef Result result_type;
    void bar() {}	
};   

template<class Result>
struct ps_foo<int*,int> {
	ps_foo<Result*,Result*>() {}
	void foo() {}
};

ps_foo<char*, char*> p;
ps_foo<int*, int> p1;

int main() {
p.bar();
 p1.foo();
; return 0; }
EOF
if { (eval echo configure:1682: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS 1
EOF
 ac_cv_partial_spec_needs_args="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  ac_cv_partial_spec_needs_args="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_partial_spec_needs_args" 1>&6

fi

echo $ac_n "checking for partial template function ordering""... $ac_c" 1>&6
echo "configure:1701: checking for partial template function ordering" >&5
cat > conftest.$ac_ext <<EOF
#line 1703 "configure"
#include "confdefs.h"


template <class Arg,class Result>
Result po_foo (const Arg& a,const Result&){ return (Result)a.nothing; }  

template <class T>
struct A {
	T a;
	A(int _a) : a(_a) {}
};

template<class T>
T po_foo (const A<T>& a, const A<T>& b){ return a.a; }   

int main() {

  A<int> po_a(0); A<int> po_b(1); (void)po_foo(po_b, po_a)

; return 0; }
EOF
if { (eval echo configure:1725: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_partial_ord="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
EOF
 ac_cv_partial_ord="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_partial_ord" 1>&6

echo $ac_n "checking for method specialization""... $ac_c" 1>&6
echo "configure:1742: checking for method specialization" >&5
cat > conftest.$ac_ext <<EOF
#line 1744 "configure"
#include "confdefs.h"

template <class Arg,class Result>
struct ms_foo {
    typedef Arg argument_type;
    typedef Result result_type;
    inline void bar();
};   

template <class Arg,class Result>
inline void ms_foo<Arg,Result>::bar() {}

inline void ms_foo<int*,int>::bar() {}

ms_foo<char*, char*> p;
ms_foo<int*, int> p1;

int main() {
p.bar();
 p1.bar();
; return 0; }
EOF
if { (eval echo configure:1767: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_method_spec="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_METHOD_SPECIALIZATION 1
EOF
 ac_cv_method_spec="no"

fi
rm -f conftest*
echo "$ac_t""$ac_cv_method_spec" 1>&6

echo $ac_n "checking for lrand48 function""... $ac_c" 1>&6
echo "configure:1784: checking for lrand48 function" >&5
cat > conftest.$ac_ext <<EOF
#line 1786 "configure"
#include "confdefs.h"
#include <stdlib.h>
int main() {
long i = lrand48();
; return 0; }
EOF
if { (eval echo configure:1793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_RAND48 1
EOF
 ac_cv_func_lrand48="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  ac_cv_func_lrand48="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_func_lrand48" 1>&6


echo $ac_n "checking for default template parameters""... $ac_c" 1>&6
echo "configure:1810: checking for default template parameters" >&5
cat > conftest.$ac_ext <<EOF
#line 1812 "configure"
#include "confdefs.h"
template <class T> struct less {}; 
     template <class T, class T1=less<T> > struct Class { T1 t1; };
     Class<int> cl;
     Class<int,less<short> > cl2;
    
int main() {

; return 0; }
EOF
if { (eval echo configure:1823: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_default_template_param="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_LIMITED_DEFAULT_TEMPLATES 1
EOF
 ac_cv_default_template_param="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_default_template_param" 1>&6
if test "$ac_cv_default_template_param" = "no"; then
  echo $ac_n "checking for default type parameters""... $ac_c" 1>&6
echo "configure:1839: checking for default type parameters" >&5
  cat > conftest.$ac_ext <<EOF
#line 1841 "configure"
#include "confdefs.h"

template <class T> struct less {
	typedef int int_t;
  }; 

template <class T, class T1=less<int> > 
struct Class { 
private:
       int a;
public:
       typedef Class<T,T1> self; 
       typedef $__TYPENAME T1::int_t int_t;
       self foo (const Class<T,T1>& t) { 
         if ( t.a==a ) return *this;
         else return t;
         } 
};

Class<int> cl;
Class<int,less<short> > cl2;
    
int main() {

; return 0; }
EOF
if { (eval echo configure:1868: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_DEFAULT_TYPE_PARAM 1
EOF
 ac_cv_default_type_param="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  ac_cv_default_type_param="no"
fi
rm -f conftest*
  echo "$ac_t""$ac_cv_default_type_param" 1>&6

fi


echo $ac_n "checking for default non-type parameters""... $ac_c" 1>&6
echo "configure:1887: checking for default non-type parameters" >&5
cat > conftest.$ac_ext <<EOF
#line 1889 "configure"
#include "confdefs.h"

template <class T, int N=0 > 
struct Class { 
private:
       T* t;
       enum { t1=N };
public:
       int get_n() { return N; }
};

Class<int> cl;
Class<int, 2> cl2;
    
int main() {

; return 0; }
EOF
if { (eval echo configure:1908: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_default_nontype_param="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1
EOF
 ac_cv_default_nontype_param="no"
	
fi
rm -f conftest*
echo "$ac_t""$ac_cv_default_nontype_param" 1>&6

echo $ac_n "checking for non-type parameter bug""... $ac_c" 1>&6
echo "configure:1925: checking for non-type parameter bug" >&5
cat > conftest.$ac_ext <<EOF
#line 1927 "configure"
#include "confdefs.h"

template <class T, int N> 
struct Class { 
private:
       T* t;
       enum { t1=N };
public:
       int get_n() { return N; }
};

template <class T, int N>
int operator==(const Class<T,N>& , const Class<T,N>& ) { return 0; }

Class<int, 1> cl;
Class<int, 1> cl2;
int i(cl==cl2);
    
int main() {

; return 0; }
EOF
if { (eval echo configure:1950: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_nontype_param_bug="no"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
EOF
 ac_cv_nontype_param_bug="yes"
	
fi
rm -f conftest*
echo "$ac_t""$ac_cv_nontype_param_bug" 1>&6

echo $ac_n "checking for static data member templates""... $ac_c" 1>&6
echo "configure:1967: checking for static data member templates" >&5
cat > conftest.$ac_ext <<EOF
#line 1969 "configure"
#include "confdefs.h"
template <class T> struct Class { static int a; };
     template <class T> int Class<T>::a;
int main() {

; return 0; }
EOF
if { (eval echo configure:1977: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_static_templates="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_NO_STATIC_TEMPLATE_DATA 1
EOF
 ac_cv_static_templates="no"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_static_templates" 1>&6

if test "$ac_cv_static_templates" = no; then
 echo $ac_n "checking for weak attribute""... $ac_c" 1>&6
echo "configure:1994: checking for weak attribute" >&5
 cat > conftest.$ac_ext <<EOF
#line 1996 "configure"
#include "confdefs.h"
int a_w __attribute__((weak));
int main() {

; return 0; }
EOF
if { (eval echo configure:2003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_WEAK_ATTRIBUTE 1
EOF
 ac_cv_weak_attribute="yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  ac_cv_weak_attribute="no"
fi
rm -f conftest*
 echo "$ac_t""$ac_cv_weak_attribute" 1>&6
fi

if test "$ac_cv_static_templates" = yes; then
echo $ac_n "checking for static array member size bug""... $ac_c" 1>&6
echo "configure:2021: checking for static array member size bug" >&5
cat > conftest.$ac_ext <<EOF
#line 2023 "configure"
#include "confdefs.h"
template <class T> struct Class { enum { sz=5 }; static int a[sz]; };
     template <class T> int Class<T>::a[Class<T>::sz];
int main() {

; return 0; }
EOF
if { (eval echo configure:2031: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_static_array_bug="no"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_STATIC_ARRAY_BUG 1
EOF
 ac_cv_static_array_bug="yes"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_static_array_bug" 1>&6
fi

echo $ac_n "checking for static data member const initializer bug""... $ac_c" 1>&6
echo "configure:2048: checking for static data member const initializer bug" >&5
cat > conftest.$ac_ext <<EOF
#line 2050 "configure"
#include "confdefs.h"
template <class T> struct Class { static const int a = 1; };
     template <class T> const int Class<T>::a;
int main() {

; return 0; }
EOF
if { (eval echo configure:2058: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  rm -rf conftest*
  ac_cv_static_init_bug="no"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  cat >> confdefs.h <<\EOF
#define _STLP_STATIC_CONST_INIT_BUG 1
EOF
 ac_cv_static_init_bug="yes"
fi
rm -f conftest*
echo "$ac_t""$ac_cv_static_init_bug" 1>&6

echo $ac_n "checking for namespaces support""... $ac_c" 1>&6
echo "configure:2074: checking for namespaces support" >&5
cat > conftest.$ac_ext <<EOF
#line 2076 "configure"
#include "confdefs.h"
class test_class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _class {};
     namespace std { 
      using ::test_class;
      _cla