# generated automatically by aclocal 1.10.2 -*- Autoconf -*-

 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,

 # 2005, 2006, 2007, 2008  Free Software Foundation, Inc.

 # This file is free software; the Free Software Foundation

 # gives unlimited permission to copy and/or distribute it,

 # with or without modifications, as long as this notice is preserved.

 # This program is distributed in the hope that it will be useful,

 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without

 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A

 # PARTICULAR PURPOSE.

 m4_ifndef([AC_AUTOCONF_VERSION],

   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl

 m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.63],,

 [m4_warning([this file was generated for autoconf 2.63.

 You have another version of autoconf.  It may work, but is not guaranteed to.

 If you have problems, you may need to regenerate the build system entirely.

 To do so, use the procedure documented by the package, typically `autoreconf'.])])

 # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-

 # serial 52 AC_PROG_LIBTOOL

 # AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)

 # -----------------------------------------------------------

 # If this macro is not defined by Autoconf, define it here.

 m4_ifdef([AC_PROVIDE_IFELSE],

          [],

          [m4_define([AC_PROVIDE_IFELSE],

 	         [m4_ifdef([AC_PROVIDE_$1],

 		           [$2], [$3])])])

 # AC_PROG_LIBTOOL

 # ---------------

 AC_DEFUN([AC_PROG_LIBTOOL],

 [AC_REQUIRE([_AC_PROG_LIBTOOL])dnl

 dnl If AC_PROG_CXX has already been expanded, run AC_LIBTOOL_CXX

 dnl immediately, otherwise, hook it in at the end of AC_PROG_CXX.

   AC_PROVIDE_IFELSE([AC_PROG_CXX],

     [AC_LIBTOOL_CXX],

     [define([AC_PROG_CXX], defn([AC_PROG_CXX])[AC_LIBTOOL_CXX

   ])])

 dnl And a similar setup for Fortran 77 support

   AC_PROVIDE_IFELSE([AC_PROG_F77],

     [AC_LIBTOOL_F77],

     [define([AC_PROG_F77], defn([AC_PROG_F77])[AC_LIBTOOL_F77

 ])])

 dnl Quote A][M_PROG_GCJ so that aclocal doesn't bring it in needlessly.

 dnl If either AC_PROG_GCJ or A][M_PROG_GCJ have already been expanded, run

 dnl AC_LIBTOOL_GCJ immediately, otherwise, hook it in at the end of both.

   AC_PROVIDE_IFELSE([AC_PROG_GCJ],

     [AC_LIBTOOL_GCJ],

     [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],

       [AC_LIBTOOL_GCJ],

       [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],

 	[AC_LIBTOOL_GCJ],

       [ifdef([AC_PROG_GCJ],

 	     [define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])

        ifdef([A][M_PROG_GCJ],

 	     [define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[AC_LIBTOOL_GCJ])])

        ifdef([LT_AC_PROG_GCJ],

 	     [define([LT_AC_PROG_GCJ],

 		defn([LT_AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])])])

 ])])# AC_PROG_LIBTOOL

 # _AC_PROG_LIBTOOL

 # ----------------

 AC_DEFUN([_AC_PROG_LIBTOOL],

 [AC_REQUIRE([AC_LIBTOOL_SETUP])dnl

 AC_BEFORE([$0],[AC_LIBTOOL_CXX])dnl

 AC_BEFORE([$0],[AC_LIBTOOL_F77])dnl

 AC_BEFORE([$0],[AC_LIBTOOL_GCJ])dnl

 # This can be used to rebuild libtool when needed

 LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

 # Always use our own libtool.

 LIBTOOL='$(SHELL) $(top_builddir)/libtool'

 AC_SUBST(LIBTOOL)dnl

 # Prevent multiple expansion

 define([AC_PROG_LIBTOOL], [])

 ])# _AC_PROG_LIBTOOL

 # AC_LIBTOOL_SETUP

 # ----------------

 AC_DEFUN([AC_LIBTOOL_SETUP],

 [AC_PREREQ(2.50)dnl

 AC_REQUIRE([AC_ENABLE_SHARED])dnl

 AC_REQUIRE([AC_ENABLE_STATIC])dnl

 AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl

 AC_REQUIRE([AC_CANONICAL_HOST])dnl

 AC_REQUIRE([AC_CANONICAL_BUILD])dnl

 AC_REQUIRE([AC_PROG_CC])dnl

 AC_REQUIRE([AC_PROG_LD])dnl

 AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl

 AC_REQUIRE([AC_PROG_NM])dnl

 AC_REQUIRE([AC_PROG_LN_S])dnl

 AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl

 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!

 AC_REQUIRE([AC_OBJEXT])dnl

 AC_REQUIRE([AC_EXEEXT])dnl

 dnl

 AC_LIBTOOL_SYS_MAX_CMD_LEN

 AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

 AC_LIBTOOL_OBJDIR

 AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

 _LT_AC_PROG_ECHO_BACKSLASH

 case $host_os in

 aix3*)

   # AIX sometimes has problems with the GCC collect2 program.  For some

   # reason, if we set the COLLECT_NAMES environment variable, the problems

   # vanish in a puff of smoke.

   if test "X${COLLECT_NAMES+set}" != Xset; then

     COLLECT_NAMES=

     export COLLECT_NAMES

   fi

   ;;

 esac

 # Sed substitution that helps us do robust quoting.  It backslashifies

 # metacharacters that are still active within double-quoted strings.

 Xsed='sed -e 1s/^X//'

 [sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']

 # Same as above, but do not quote variable references.

 [double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']

 # Sed substitution to delay expansion of an escaped shell variable in a

 # double_quote_subst'ed string.

 delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

 # Sed substitution to avoid accidental globbing in evaled expressions

 no_glob_subst='s/\*/\\\*/g'

 # Constants:

 rm="rm -f"

 # Global variables:

 default_ofile=libtool

 can_build_shared=yes

 # All known linkers require a `.a' archive for static linking (except MSVC,

 # which needs '.lib').

 libext=a

 ltmain="$ac_aux_dir/ltmain.sh"

 ofile="$default_ofile"

 with_gnu_ld="$lt_cv_prog_gnu_ld"

 AC_CHECK_TOOL(AR, ar, false)

 AC_CHECK_TOOL(RANLIB, ranlib, :)

 AC_CHECK_TOOL(STRIP, strip, :)

 old_CC="$CC"

 old_CFLAGS="$CFLAGS"

 # Set sane defaults for various variables

 test -z "$AR" && AR=ar

 test -z "$AR_FLAGS" && AR_FLAGS=cru

 test -z "$AS" && AS=as

 test -z "$CC" && CC=cc

 test -z "$LTCC" && LTCC=$CC

 test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS

 test -z "$DLLTOOL" && DLLTOOL=dlltool

 test -z "$LD" && LD=ld

 test -z "$LN_S" && LN_S="ln -s"

 test -z "$MAGIC_CMD" && MAGIC_CMD=file

 test -z "$NM" && NM=nm

 test -z "$SED" && SED=sed

 test -z "$OBJDUMP" && OBJDUMP=objdump

 test -z "$RANLIB" && RANLIB=:

 test -z "$STRIP" && STRIP=:

 test -z "$ac_objext" && ac_objext=o

 # Determine commands to create old-style static archives.

 old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'

 old_postinstall_cmds='chmod 644 $oldlib'

 old_postuninstall_cmds=

 if test -n "$RANLIB"; then

   case $host_os in

   openbsd*)

     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"

     ;;

   *)

     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"

     ;;

   esac

   old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"

 fi

 _LT_CC_BASENAME([$compiler])

 # Only perform the check for file, if the check method requires it

 case $deplibs_check_method in

 file_magic*)

   if test "$file_magic_cmd" = '$MAGIC_CMD'; then

     AC_PATH_MAGIC

   fi

   ;;

 esac

 _LT_REQUIRED_DARWIN_CHECKS

 AC_PROVIDE_IFELSE([AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)

 AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

 enable_win32_dll=yes, enable_win32_dll=no)

 AC_ARG_ENABLE([libtool-lock],

     [AC_HELP_STRING([--disable-libtool-lock],

 	[avoid locking (might break parallel builds)])])

 test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

 AC_ARG_WITH([pic],

     [AC_HELP_STRING([--with-pic],

 	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],

     [pic_mode="$withval"],

     [pic_mode=default])

 test -z "$pic_mode" && pic_mode=default

 # Check if we have a version mismatch between libtool.m4 and ltmain.sh.

 #

 # Note:  This should be in AC_LIBTOOL_SETUP, _after_ $ltmain have been defined.

 #        We also should do it _before_ AC_LIBTOOL_LANG_C_CONFIG that actually

 #        calls AC_LIBTOOL_CONFIG and creates libtool.

 #

 _LT_VERSION_CHECK

 # Use C for the default configuration in the libtool script

 tagname=

 AC_LIBTOOL_LANG_C_CONFIG

 _LT_AC_TAGCONFIG

 ])# AC_LIBTOOL_SETUP

 # _LT_VERSION_CHECK

 # -----------------

 AC_DEFUN([_LT_VERSION_CHECK],

 [AC_MSG_CHECKING([for correct ltmain.sh version])

 if test "x$ltmain" = "x" ; then

   AC_MSG_RESULT(no)

   AC_MSG_ERROR([

 *** @<:@Gentoo@:>@ sanity check failed! ***

 *** \$ltmain is not defined, please check the patch for consistency! ***

 ])

 fi

 gentoo_lt_version="1.5.26"

 gentoo_ltmain_version=`sed -n '/^[[ 	]]*VERSION=/{s/^[[ 	]]*VERSION=//;p;q;}' "$ltmain"`

 if test "x$gentoo_lt_version" != "x$gentoo_ltmain_version" ; then

   AC_MSG_RESULT(no)

   AC_MSG_ERROR([

 *** @<:@Gentoo@:>@ sanity check failed! ***

 *** libtool.m4 and ltmain.sh have a version mismatch! ***

 *** (libtool.m4 = $gentoo_lt_version, ltmain.sh = $gentoo_ltmain_version) ***

 Please run:

   libtoolize --copy --force

 if appropriate, please contact the maintainer of this

 package (or your distribution) for help.

 ])

 else

   AC_MSG_RESULT(yes)

 fi

 ])# _LT_VERSION_CHECK

 # _LT_AC_SYS_COMPILER

 # -------------------

 AC_DEFUN([_LT_AC_SYS_COMPILER],

 [AC_REQUIRE([AC_PROG_CC])dnl

 # If no C compiler was specified, use CC.

 LTCC=${LTCC-"$CC"}

 # If no C compiler flags were specified, use CFLAGS.

 LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

 # Allow CC to be a program name with arguments.

 compiler=$CC

 ])# _LT_AC_SYS_COMPILER

 # _LT_CC_BASENAME(CC)

 # -------------------

 # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.

 AC_DEFUN([_LT_CC_BASENAME],

 [for cc_temp in $1""; do

   case $cc_temp in

     compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;

     distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;

     \-*) ;;

     *) break;;

   esac

 done

 cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

 ])

 # _LT_COMPILER_BOILERPLATE

 # ------------------------

 # Check for compiler boilerplate output or warnings with

 # the simple compiler test code.

 AC_DEFUN([_LT_COMPILER_BOILERPLATE],

 [AC_REQUIRE([LT_AC_PROG_SED])dnl

 ac_outfile=conftest.$ac_objext

 echo "$lt_simple_compile_test_code" >conftest.$ac_ext

 eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

 _lt_compiler_boilerplate=`cat conftest.err`

 $rm conftest*

 ])# _LT_COMPILER_BOILERPLATE

 # _LT_LINKER_BOILERPLATE

 # ----------------------

 # Check for linker boilerplate output or warnings with

 # the simple link test code.

 AC_DEFUN([_LT_LINKER_BOILERPLATE],

 [AC_REQUIRE([LT_AC_PROG_SED])dnl

 ac_outfile=conftest.$ac_objext

 echo "$lt_simple_link_test_code" >conftest.$ac_ext

 eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

 _lt_linker_boilerplate=`cat conftest.err`

 $rm -r conftest*

 ])# _LT_LINKER_BOILERPLATE

 # _LT_REQUIRED_DARWIN_CHECKS

 # --------------------------

 # Check for some things on darwin

 AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS],[

   case $host_os in

     rhapsody* | darwin*)

     AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])

     AC_CHECK_TOOL([NMEDIT], [nmedit], [:])

     AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],

       [lt_cv_apple_cc_single_mod=no

       if test -z "${LT_MULTI_MODULE}"; then

    # By default we will add the -single_module flag. You can override

    # by either setting the environment variable LT_MULTI_MODULE

    # non-empty at configure time, or by adding -multi_module to the

    # link flags.

    echo "int foo(void){return 1;}" > conftest.c

    $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \

      -dynamiclib ${wl}-single_module conftest.c

    if test -f libconftest.dylib; then

      lt_cv_apple_cc_single_mod=yes

      rm -rf libconftest.dylib*

    fi

    rm conftest.c

       fi])

     AC_CACHE_CHECK([for -exported_symbols_list linker flag],

       [lt_cv_ld_exported_symbols_list],

       [lt_cv_ld_exported_symbols_list=no

       save_LDFLAGS=$LDFLAGS

       echo "_main" > conftest.sym

       LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"

       AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],

    [lt_cv_ld_exported_symbols_list=yes],

    [lt_cv_ld_exported_symbols_list=no])

    LDFLAGS="$save_LDFLAGS"

     ])

     case $host_os in

     rhapsody* | darwin1.[[0123]])

       _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;

     darwin1.*)

      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;

     darwin*)

       # if running on 10.5 or later, the deployment target defaults

       # to the OS version, if on x86, and 10.4, the deployment

       # target defaults to 10.4. Don't you love it?

       case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in

    10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)

      _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;

    10.[[012]]*)

      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;

    10.*)

      _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;

       esac

     ;;

   esac

     if test "$lt_cv_apple_cc_single_mod" = "yes"; then

       _lt_dar_single_mod='$single_module'

     fi

     if test "$lt_cv_ld_exported_symbols_list" = "yes"; then

       _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'

     else

       _lt_dar_export_syms="~$NMEDIT -s \$output_objdir/\${libname}-symbols.expsym \${lib}"

     fi

     if test "$DSYMUTIL" != ":"; then

       _lt_dsymutil="~$DSYMUTIL \$lib || :"

     else

       _lt_dsymutil=

     fi

     ;;

   esac

 ])

 # _LT_AC_SYS_LIBPATH_AIX

 # ----------------------

 # Links a minimal program and checks the executable

 # for the system default hardcoded library path. In most cases,

 # this is /usr/lib:/lib, but when the MPI compilers are used

 # the location of the communication and MPI libs are included too.

 # If we don't find anything, use the default library path according

 # to the aix ld manual.

 AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX],

 [AC_REQUIRE([LT_AC_PROG_SED])dnl

 AC_LINK_IFELSE(AC_LANG_PROGRAM,[

 lt_aix_libpath_sed='

     /Import File Strings/,/^$/ {

 	/^0/ {

 	    s/^0  *\(.*\)$/\1/

 	    p

 	}

     }'

 aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

 # Check for a 64-bit object if we didn't find anything.

 if test -z "$aix_libpath"; then

   aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

 fi],[])

 if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

 ])# _LT_AC_SYS_LIBPATH_AIX

 # _LT_AC_SHELL_INIT(ARG)

 # ----------------------

 AC_DEFUN([_LT_AC_SHELL_INIT],

 [ifdef([AC_DIVERSION_NOTICE],

 	     [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],

 	 [AC_DIVERT_PUSH(NOTICE)])

 $1

 AC_DIVERT_POP

 ])# _LT_AC_SHELL_INIT

 # _LT_AC_PROG_ECHO_BACKSLASH

 # --------------------------

 # Add some code to the start of the generated configure script which

 # will find an echo command which doesn't interpret backslashes.

 AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],

 [_LT_AC_SHELL_INIT([

 # Check that we are running under the correct shell.

 SHELL=${CONFIG_SHELL-/bin/sh}

 case X$ECHO in

 X*--fallback-echo)

   # Remove one level of quotation (which was required for Make).

   ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`

   ;;

 esac

 echo=${ECHO-echo}

 if test "X[$]1" = X--no-reexec; then

   # Discard the --no-reexec flag, and continue.

   shift

 elif test "X[$]1" = X--fallback-echo; then

   # Avoid inline document here, it may be left over

   :

 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then

   # Yippee, $echo works!

   :

 else

   # Restart under the correct shell.

   exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}

 fi

 if test "X[$]1" = X--fallback-echo; then

   # used as fallback echo

   shift

   cat <<EOF

 [$]*

 EOF

   exit 0

 fi

 # The HP-UX ksh and POSIX shell print the target directory to stdout

 # if CDPATH is set.

 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH

 if test -z "$ECHO"; then

 if test "X${echo_test_string+set}" != Xset; then

 # find a string as large as possible, as long as the shell can cope with it

   for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do

     # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...

     if (echo_test_string=`eval $cmd`) 2>/dev/null &&

        echo_test_string=`eval $cmd` &&

        (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null

     then

       break

     fi

   done

 fi

 if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&

    echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&

    test "X$echo_testing_string" = "X$echo_test_string"; then

   :

 else

   # The Solaris, AIX, and Digital Unix default echo programs unquote

   # backslashes.  This makes it impossible to quote backslashes using

   #   echo "$something" | sed 's/\\/\\\\/g'

   #

   # So, first we look for a working echo in the user's PATH.

   lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

   for dir in $PATH /usr/ucb; do

     IFS="$lt_save_ifs"

     if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&

        test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&

        echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&

        test "X$echo_testing_string" = "X$echo_test_string"; then

       echo="$dir/echo"

       break

     fi

   done

   IFS="$lt_save_ifs"

   if test "X$echo" = Xecho; then

     # We didn't find a better echo, so look for alternatives.

     if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&

        echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&

        test "X$echo_testing_string" = "X$echo_test_string"; then

       # This shell has a builtin print -r that does the trick.

       echo='print -r'

     elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&

 	 test "X$CONFIG_SHELL" != X/bin/ksh; then

       # If we have ksh, try running configure again with it.

       ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}

       export ORIGINAL_CONFIG_SHELL

       CONFIG_SHELL=/bin/ksh

       export CONFIG_SHELL

       exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}

     else

       # Try using printf.

       echo='printf %s\n'

       if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&

 	 echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&

 	 test "X$echo_testing_string" = "X$echo_test_string"; then

 	# Cool, printf works

 	:

       elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

 	   test "X$echo_testing_string" = 'X\t' &&

 	   echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

 	   test "X$echo_testing_string" = "X$echo_test_string"; then

 	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL

 	export CONFIG_SHELL

 	SHELL="$CONFIG_SHELL"

 	export SHELL

 	echo="$CONFIG_SHELL [$]0 --fallback-echo"

       elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

 	   test "X$echo_testing_string" = 'X\t' &&

 	   echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

 	   test "X$echo_testing_string" = "X$echo_test_string"; then

 	echo="$CONFIG_SHELL [$]0 --fallback-echo"

       else

 	# maybe with a smaller string...

 	prev=:

 	for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do

 	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null

 	  then

 	    break

 	  fi

 	  prev="$cmd"

 	done

 	if test "$prev" != 'sed 50q "[$]0"'; then

 	  echo_test_string=`eval $prev`

 	  export echo_test_string

 	  exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}

 	else

 	  # Oops.  We lost completely, so just stick with echo.

 	  echo=echo

 	fi

       fi

     fi

   fi

 fi

 fi

 # Copy echo and quote the copy suitably for passing to libtool from

 # the Makefile, instead of quoting the original, which is used later.

 ECHO=$echo

 if test "X$ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then

    ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"

 fi

 AC_SUBST(ECHO)

 ])])# _LT_AC_PROG_ECHO_BACKSLASH

 # _LT_AC_LOCK

 # -----------

 AC_DEFUN([_LT_AC_LOCK],

 [AC_ARG_ENABLE([libtool-lock],

     [AC_HELP_STRING([--disable-libtool-lock],

 	[avoid locking (might break parallel builds)])])

 test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

 # Some flags need to be propagated to the compiler or linker for good

 # libtool support.

 case $host in

 ia64-*-hpux*)

   # Find out which ABI we are using.

   echo 'int i;' > conftest.$ac_ext

   if AC_TRY_EVAL(ac_compile); then

     case `/usr/bin/file conftest.$ac_objext` in

     *ELF-32*)

       HPUX_IA64_MODE="32"

       ;;

     *ELF-64*)

       HPUX_IA64_MODE="64"

       ;;

     esac

   fi

   rm -rf conftest*

   ;;

 *-*-irix6*)

   # Find out which ABI we are using.

   echo '[#]line __oline__ "configure"' > conftest.$ac_ext

   if AC_TRY_EVAL(ac_compile); then

    if test "$lt_cv_prog_gnu_ld" = yes; then

     case `/usr/bin/file conftest.$ac_objext` in

     *32-bit*)

       LD="${LD-ld} -melf32bsmip"

       ;;

     *N32*)

       LD="${LD-ld} -melf32bmipn32"

       ;;

     *64-bit*)

       LD="${LD-ld} -melf64bmip"

       ;;

     esac

    else

     case `/usr/bin/file conftest.$ac_objext` in

     *32-bit*)

       LD="${LD-ld} -32"

       ;;

     *N32*)

       LD="${LD-ld} -n32"

       ;;

     *64-bit*)

       LD="${LD-ld} -64"

       ;;

     esac

    fi

   fi

   rm -rf conftest*

   ;;

 x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \

 s390*-*linux*|sparc*-*linux*)

   # Find out which ABI we are using.

   echo 'int i;' > conftest.$ac_ext

   if AC_TRY_EVAL(ac_compile); then

     case `/usr/bin/file conftest.o` in

     *32-bit*)

       case $host in

         x86_64-*kfreebsd*-gnu)

           LD="${LD-ld} -m elf_i386_fbsd"

           ;;

         x86_64-*linux*)

           LD="${LD-ld} -m elf_i386"

           ;;

         ppc64-*linux*|powerpc64-*linux*)

           LD="${LD-ld} -m elf32ppclinux"

           ;;

         s390x-*linux*)

           LD="${LD-ld} -m elf_s390"

           ;;

         sparc64-*linux*)

           LD="${LD-ld} -m elf32_sparc"

           ;;

       esac

       ;;

     *64-bit*)

       case $host in

         x86_64-*kfreebsd*-gnu)

           LD="${LD-ld} -m elf_x86_64_fbsd"

           ;;

         x86_64-*linux*)

           LD="${LD-ld} -m elf_x86_64"

           ;;

         ppc*-*linux*|powerpc*-*linux*)

           LD="${LD-ld} -m elf64ppc"

           ;;

         s390*-*linux*)

           LD="${LD-ld} -m elf64_s390"

           ;;

         sparc*-*linux*)

           LD="${LD-ld} -m elf64_sparc"

           ;;

       esac

       ;;

     esac

   fi

   rm -rf conftest*

   ;;

 *-*-sco3.2v5*)

   # On SCO OpenServer 5, we need -belf to get full-featured binaries.

   SAVE_CFLAGS="$CFLAGS"

   CFLAGS="$CFLAGS -belf"

   AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,

     [AC_LANG_PUSH(C)

      AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])

      AC_LANG_POP])

   if test x"$lt_cv_cc_needs_belf" != x"yes"; then

     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf

     CFLAGS="$SAVE_CFLAGS"

   fi

   ;;

 sparc*-*solaris*)

   # Find out which ABI we are using.

   echo 'int i;' > conftest.$ac_ext

   if AC_TRY_EVAL(ac_compile); then

     case `/usr/bin/file conftest.o` in

     *64-bit*)

       case $lt_cv_prog_gnu_ld in

       yes*) LD="${LD-ld} -m elf64_sparc" ;;

       *)

         if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then

 	  LD="${LD-ld} -64"

 	fi

 	;;

       esac

       ;;

     esac

   fi

   rm -rf conftest*

   ;;

 AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

 [*-*-cygwin* | *-*-mingw* | *-*-pw32*)

   AC_CHECK_TOOL(DLLTOOL, dlltool, false)

   AC_CHECK_TOOL(AS, as, false)

   AC_CHECK_TOOL(OBJDUMP, objdump, false)

   ;;

   ])

 esac

 need_locks="$enable_libtool_lock"

 ])# _LT_AC_LOCK

 # AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

 #		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])

 # ----------------------------------------------------------------

 # Check whether the given compiler option works

 AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],

 [AC_REQUIRE([LT_AC_PROG_SED])

 AC_CACHE_CHECK([$1], [$2],

   [$2=no

   ifelse([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])

    echo "$lt_simple_compile_test_code" > conftest.$ac_ext

    lt_compiler_flag="$3"

    # Insert the option either (1) after the last *FLAGS variable, or

    # (2) before a word containing "conftest.", or (3) at the end.

    # Note that $ac_compile itself does not contain backslashes and begins

    # with a dollar sign (not a hyphen), so the echo should work correctly.

    # The option is referenced via a variable to avoid confusing sed.

    lt_compile=`echo "$ac_compile" | $SED \

    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

    -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \

    -e 's:$: $lt_compiler_flag:'`

    (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

    (eval "$lt_compile" 2>conftest.err)

    ac_status=$?

    cat conftest.err >&AS_MESSAGE_LOG_FD

    echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

    if (exit $ac_status) && test -s "$ac_outfile"; then

      # The compiler can only warn and ignore the option if not recognized

      # So say no if there are warnings other than the usual output.

      $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

      $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

      if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

        $2=yes

      fi

    fi

    $rm conftest*

 ])

 if test x"[$]$2" = xyes; then

     ifelse([$5], , :, [$5])

 else

     ifelse([$6], , :, [$6])

 fi

 ])# AC_LIBTOOL_COMPILER_OPTION

 # AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

 #                          [ACTION-SUCCESS], [ACTION-FAILURE])

 # ------------------------------------------------------------

 # Check whether the given compiler option works

 AC_DEFUN([AC_LIBTOOL_LINKER_OPTION],

 [AC_REQUIRE([LT_AC_PROG_SED])dnl

 AC_CACHE_CHECK([$1], [$2],

   [$2=no

    save_LDFLAGS="$LDFLAGS"

    LDFLAGS="$LDFLAGS $3"

    echo "$lt_simple_link_test_code" > conftest.$ac_ext

    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then

      # The linker can only warn and ignore the option if not recognized

      # So say no if there are warnings

      if test -s conftest.err; then

        # Append any errors to the config.log.

        cat conftest.err 1>&AS_MESSAGE_LOG_FD

        $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

        $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

        if diff conftest.exp conftest.er2 >/dev/null; then

          $2=yes

        fi

      else

        $2=yes

      fi

    fi

    $rm -r conftest*

    LDFLAGS="$save_LDFLAGS"

 ])

 if test x"[$]$2" = xyes; then

     ifelse([$4], , :, [$4])

 else

     ifelse([$5], , :, [$5])

 fi

 ])# AC_LIBTOOL_LINKER_OPTION

 # AC_LIBTOOL_SYS_MAX_CMD_LEN

 # --------------------------

 AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],

 [# find the maximum length of command line arguments

 AC_MSG_CHECKING([the maximum length of command line arguments])

 AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl

   i=0

   teststring="ABCD"

   case $build_os in

   msdosdjgpp*)

     # On DJGPP, this test can blow up pretty badly due to problems in libc

     # (any single argument exceeding 2000 bytes causes a buffer overrun

     # during glob expansion).  Even if it were fixed, the result of this

     # check would be larger than it should be.

     lt_cv_sys_max_cmd_len=12288;    # 12K is about right

     ;;

   gnu*)

     # Under GNU Hurd, this test is not required because there is

     # no limit to the length of command line arguments.

     # Libtool will interpret -1 as no limit whatsoever

     lt_cv_sys_max_cmd_len=-1;

     ;;

   cygwin* | mingw*)

     # On Win9x/ME, this test blows up -- it succeeds, but takes

     # about 5 minutes as the teststring grows exponentially.

     # Worse, since 9x/ME are not pre-emptively multitasking,

     # you end up with a "frozen" computer, even though with patience

     # the test eventually succeeds (with a max line length of 256k).

     # Instead, let's just punt: use the minimum linelength reported by

     # all of the supported platforms: 8192 (on NT/2K/XP).

     lt_cv_sys_max_cmd_len=8192;

     ;;

   amigaos*)

     # On AmigaOS with pdksh, this test takes hours, literally.

     # So we just punt and use a minimum line length of 8192.

     lt_cv_sys_max_cmd_len=8192;

     ;;

   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)

     # This has been around since 386BSD, at least.  Likely further.

     if test -x /sbin/sysctl; then

       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`

     elif test -x /usr/sbin/sysctl; then

       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`

     else

       lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs

     fi

     # And add a safety zone

     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`

     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`

     ;;

   interix*)

     # We know the value 262144 and hardcode it with a safety zone (like BSD)

     lt_cv_sys_max_cmd_len=196608

     ;;

   osf*)

     # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure

     # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not

     # nice to cause kernel panics so lets avoid the loop below.

     # First set a reasonable default.

     lt_cv_sys_max_cmd_len=16384

     #

     if test -x /sbin/sysconfig; then

       case `/sbin/sysconfig -q proc exec_disable_arg_limit` in

         *1*) lt_cv_sys_max_cmd_len=-1 ;;

       esac

     fi

     ;;

   sco3.2v5*)

     lt_cv_sys_max_cmd_len=102400

     ;;

   sysv5* | sco5v6* | sysv4.2uw2*)

     kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`

     if test -n "$kargmax"; then

       lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ 	]]//'`

     else

       lt_cv_sys_max_cmd_len=32768

     fi

     ;;

   *)

     lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`

     if test -n "$lt_cv_sys_max_cmd_len"; then

       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`

       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`

     else

       SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}

       while (test "X"`$SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \

 	       = "XX$teststring") >/dev/null 2>&1 &&

 	      new_result=`expr "X$teststring" : ".*" 2>&1` &&

 	      lt_cv_sys_max_cmd_len=$new_result &&

 	      test $i != 17 # 1/2 MB should be enough

       do

         i=`expr $i + 1`

         teststring=$teststring$teststring

       done

       teststring=

       # Add a significant safety factor because C++ compilers can tack on massive

       # amounts of additional arguments before passing them to the linker.

       # It appears as though 1/2 is a usable value.

       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`

     fi

     ;;

   esac

 ])

 if test -n $lt_cv_sys_max_cmd_len ; then

   AC_MSG_RESULT($lt_cv_sys_max_cmd_len)

 else

   AC_MSG_RESULT(none)

 fi

 ])# AC_LIBTOOL_SYS_MAX_CMD_LEN

 # _LT_AC_CHECK_DLFCN

 # ------------------

 AC_DEFUN([_LT_AC_CHECK_DLFCN],

 [AC_CHECK_HEADERS(dlfcn.h)dnl

 ])# _LT_AC_CHECK_DLFCN

 # _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,

 #                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)

 # ---------------------------------------------------------------------

 AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],

 [AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

 if test "$cross_compiling" = yes; then :

   [$4]

 else

   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

   lt_status=$lt_dlunknown

   cat > conftest.$ac_ext <<EOF

 [#line __oline__ "configure"

 #include "confdefs.h"

 #if HAVE_DLFCN_H

 #include <dlfcn.h>

 #endif

 #include <stdio.h>

 #ifdef RTLD_GLOBAL

 #  define LT_DLGLOBAL		RTLD_GLOBAL

 #else

 #  ifdef DL_GLOBAL

 #    define LT_DLGLOBAL		DL_GLOBAL

 #  else

 #    define LT_DLGLOBAL		0

 #  endif

 #endif

 /* We may have to define LT_DLLAZY_OR_NOW in the command line if we

    find out it does not work in some platform. */

 #ifndef LT_DLLAZY_OR_NOW

 #  ifdef RTLD_LAZY

 #    define LT_DLLAZY_OR_NOW		RTLD_LAZY

 #  else

 #    ifdef DL_LAZY

 #      define LT_DLLAZY_OR_NOW		DL_LAZY

 #    else

 #      ifdef RTLD_NOW

 #        define LT_DLLAZY_OR_NOW	RTLD_NOW

 #      else

 #        ifdef DL_NOW

 #          define LT_DLLAZY_OR_NOW	DL_NOW

 #        else

 #          define LT_DLLAZY_OR_NOW	0

 #        endif

 #      endif

 #    endif

 #  endif

 #endif

 #ifdef __cplusplus

 extern "C" void exit (int);

 #endif

 void fnord() { int i=42;}

 int main ()

 {

   void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);

   int status = $lt_dlunknown;

   if (self)

     {

       if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;

       else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

       /* dlclose (self); */

     }

   else

     puts (dlerror ());

     exit (status);

 }]

 EOF

   if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then

     (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null

     lt_status=$?

     case x$lt_status in

       x$lt_dlno_uscore) $1 ;;

       x$lt_dlneed_uscore) $2 ;;

       x$lt_dlunknown|x*) $3 ;;

     esac

   else :

     # compilation failed

     $3

   fi

 fi

 rm -fr conftest*

 ])# _LT_AC_TRY_DLOPEN_SELF

 # AC_LIBTOOL_DLOPEN_SELF

 # ----------------------

 AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],

 [AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

 if test "x$enable_dlopen" != xyes; then

   enable_dlopen=unknown

   enable_dlopen_self=unknown

   enable_dlopen_self_static=unknown

 else

   lt_cv_dlopen=no

   lt_cv_dlopen_libs=

   case $host_os in

   beos*)

     lt_cv_dlopen="load_add_on"

     lt_cv_dlopen_libs=

     lt_cv_dlopen_self=yes

     ;;

   mingw* | pw32*)

     lt_cv_dlopen="LoadLibrary"

     lt_cv_dlopen_libs=

    ;;

   cygwin*)

     lt_cv_dlopen="dlopen"

     lt_cv_dlopen_libs=

    ;;

   darwin*)

   # if libdl is installed we need to link against it

     AC_CHECK_LIB([dl], [dlopen],

 		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[

     lt_cv_dlopen="dyld"

     lt_cv_dlopen_libs=

     lt_cv_dlopen_self=yes

     ])

    ;;

   *)

     AC_CHECK_FUNC([shl_load],

 	  [lt_cv_dlopen="shl_load"],

       [AC_CHECK_LIB([dld], [shl_load],

 	    [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"],

 	[AC_CHECK_FUNC([dlopen],

 	      [lt_cv_dlopen="dlopen"],

 	  [AC_CHECK_LIB([dl], [dlopen],

 		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],

 	    [AC_CHECK_LIB([svld], [dlopen],

 		  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],

 	      [AC_CHECK_LIB([dld], [dld_link],

 		    [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"])

 	      ])

 	    ])

 	  ])

 	])

       ])

     ;;

   esac

   if test "x$lt_cv_dlopen" != xno; then

     enable_dlopen=yes

   else

     enable_dlopen=no

   fi

   case $lt_cv_dlopen in

   dlopen)

     save_CPPFLAGS="$CPPFLAGS"

     test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"

     save_LDFLAGS="$LDFLAGS"

     wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

     save_LIBS="$LIBS"

     LIBS="$lt_cv_dlopen_libs $LIBS"

     AC_CACHE_CHECK([whether a program can dlopen itself],

 	  lt_cv_dlopen_self, [dnl

 	  _LT_AC_TRY_DLOPEN_SELF(

 	    lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,

 	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)

     ])

     if test "x$lt_cv_dlopen_self" = xyes; then

       wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"

       AC_CACHE_CHECK([whether a statically linked program can dlopen itself],

     	  lt_cv_dlopen_self_static, [dnl

 	  _LT_AC_TRY_DLOPEN_SELF(

 	    lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,

 	    lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)

       ])

     fi

     CPPFLAGS="$save_CPPFLAGS"

     LDFLAGS="$save_LDFLAGS"

     LIBS="$save_LIBS"

     ;;

   esac

   case $lt_cv_dlopen_self in

   yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;

   *) enable_dlopen_self=unknown ;;

   esac

   case $lt_cv_dlopen_self_static in

   yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;

   *) enable_dlopen_self_static=unknown ;;

   esac

 fi

 ])# AC_LIBTOOL_DLOPEN_SELF

 # AC_LIBTOOL_PROG_CC_C_O([TAGNAME])

 # ---------------------------------

 # Check to see if options -c and -o are simultaneously supported by compiler

 AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],

 [AC_REQUIRE([LT_AC_PROG_SED])dnl

 AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

 AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],

   [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],

   [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no

    $rm -r conftest 2>/dev/null

    mkdir conftest

    cd conftest

    mkdir out

    echo "$lt_simple_compile_test_code" > conftest.$ac_ext

    lt_compiler_flag="-o out/conftest2.$ac_objext"

    # Insert the option either (1) after the last *FLAGS variable, or

    # (2) before a word containing "conftest.", or (3) at the end.

    # Note that $ac_compile itself does not contain backslashes and begins

    # with a dollar sign (not a hyphen), so the echo should work correctly.

    lt_compile=`echo "$ac_compile" | $SED \

    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

    -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \

    -e 's:$: $lt_compiler_flag:'`

    (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

    (eval "$lt_compile" 2>out/conftest.err)

    ac_status=$?

    cat out/conftest.err >&AS_MESSAGE_LOG_FD

    echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

    if (exit $ac_status) && test -s out/conftest2.$ac_objext

    then

      # The compiler can only warn and ignore the option if not recognized

      # So say no if there are warnings

      $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp

      $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2