[ViewVC] Diff of: OpenMD/branches/development/configure

Comparing trunk/configure (file contents):
Revision 1311 by gezelter, Tue Oct 21 18:50:37 2008 UTC vs.
Revision 1373 by gezelter, Tue Oct 20 13:13:45 2009 UTC

#	Line 1 \| Line 1
1		#! /bin/sh
2		# Guess values for system-dependent variables and create Makefiles.
3	<	# Generated by GNU Autoconf 2.62 for OOPSE 4.0.
3	>	# Generated by GNU Autoconf 2.64 for OOPSE 4.0.
4		#
5		# Report bugs to <gezelter@nd.edu>.
6		#
7		# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
8	<	# 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
8	>	# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
9	>	# Foundation, Inc.
10	>	#
11		# This configure script is free software; the Free Software Foundation
12		# gives unlimited permission to copy, distribute and modify it.
13	<	## --------------------- ##
14	<	## M4sh Initialization. ##
15	<	## --------------------- ##
13	>	## -------------------- ##
14	>	## M4sh Initialization. ##
15	>	## -------------------- ##
16
17		# Be more Bourne compatible
18		DUALCASE=1; export DUALCASE # for MKS sh
19	<	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
19	>	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
20		emulate sh
21		NULLCMD=:
22		# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
#	Line 22 \| Line 24 \| else
24		alias -g '${1+"$@"}'='"$@"'
25		setopt NO_GLOB_SUBST
26		else
27	<	case `(set -o) 2>/dev/null` in
28	<	posix) set -o posix ;;
27	>	case `(set -o) 2>/dev/null` in #(
28	>	posix) :
29	>	set -o posix ;; #(
30	>	*) :
31	>	;;
32		esac
28	–
33		fi
34
35
32	–
33	–
34	–	# PATH needs CR
35	–	# Avoid depending upon Character Ranges.
36	–	as_cr_letters='abcdefghijklmnopqrstuvwxyz'
37	–	as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
38	–	as_cr_Letters=$as_cr_letters$as_cr_LETTERS
39	–	as_cr_digits='0123456789'
40	–	as_cr_alnum=$as_cr_Letters$as_cr_digits
41	–
36		as_nl='
37		'
38		export as_nl
#	Line 46 \| Line 40 \| as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_ec
40		as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
41		as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
42		as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
43	<	if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
43	>	# Prefer a ksh shell builtin over an external printf program on Solaris,
44	>	# but without wasting forks for bash or zsh.
45	>	if test -z "$BASH_VERSION$ZSH_VERSION" \
46	>	&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
47	>	as_echo='print -r --'
48	>	as_echo_n='print -rn --'
49	>	elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
50		as_echo='printf %s\n'
51		as_echo_n='printf %s'
52		else
#	Line 57 \| Line 57 \| else
57		as_echo_body='eval expr "X$1" : "X\$.*\$"'
58		as_echo_n_body='eval
59		arg=$1;
60	<	case $arg in
60	>	case $arg in #(
61		"$as_nl")
62		expr "X$arg" : "X\$.*\$$as_nl";
63		arg=`expr "X$arg" : ".$as_nl\$.\$"`;;
#	Line 80 \| Line 80 \| fi
80		}
81		fi
82
83	–	# Support unset when possible.
84	–	if ( (MAIL=60; unset MAIL) \|\| exit) >/dev/null 2>&1; then
85	–	as_unset=unset
86	–	else
87	–	as_unset=false
88	–	fi
83
90	–
84		# IFS
85		# We need space, tab and new line, in precisely that order. Quoting is
86		# there to prevent editors from complaining about space-tab.
#	Line 96 \| Line 89 \| IFS=" "" $as_nl"
89		IFS=" "" $as_nl"
90
91		# Find who we are. Look in the path if we contain no directory separator.
92	<	case $0 in
92	>	case $0 in #((
93		[\\/] ) as_myself=$0 ;;
94		*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
95		for as_dir in $PATH
96		do
97		IFS=$as_save_IFS
98		test -z "$as_dir" && as_dir=.
99	<	test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
100	<	done
99	>	test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
100	>	done
101		IFS=$as_save_IFS
102
103		;;
#	Line 116 \| Line 109 \| if test ! -f "$as_myself"; then
109		fi
110		if test ! -f "$as_myself"; then
111		$as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
112	<	{ (exit 1); exit 1; }
112	>	exit 1
113		fi
114
115	<	# Work around bugs in pre-3.0 UWIN ksh.
116	<	for as_var in ENV MAIL MAILPATH
117	<	do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
115	>	# Unset variables that we do not need and which cause bugs (e.g. in
116	>	# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "\|\| exit 1"
117	>	# suppresses any "Segmentation fault" message there. '((' could
118	>	# trigger a bug in pdksh 5.2.14.
119	>	for as_var in BASH_ENV ENV MAIL MAILPATH
120	>	do eval test x\${$as_var+set} = xset \
121	>	&& ( (unset $as_var) \|\| exit 1) >/dev/null 2>&1 && unset $as_var \|\| :
122		done
123		PS1='$ '
124		PS2='> '
#	Line 133 \| Line 130 \| export LANGUAGE
130		LANGUAGE=C
131		export LANGUAGE
132
133	<	# Required to use basename.
134	<	if expr a : '$a$' >/dev/null 2>&1 &&
138	<	test "X`expr 00001 : '.*$...$'`" = X001; then
139	<	as_expr=expr
140	<	else
141	<	as_expr=false
142	<	fi
133	>	# CDPATH.
134	>	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
135
136	<	if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
137	<	as_basename=basename
136	>	if test "x$CONFIG_SHELL" = x; then
137	>	as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
138	>	emulate sh
139	>	NULLCMD=:
140	>	# Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
141	>	# is contrary to our usage. Disable this feature.
142	>	alias -g '\${1+\"\$@\"}'='\"\$@\"'
143	>	setopt NO_GLOB_SUBST
144		else
145	<	as_basename=false
145	>	case \`(set -o) 2>/dev/null\` in #(
146	>	posix) :
147	>	set -o posix ;; #(
148	>	*) :
149	>	;;
150	>	esac
151		fi
152	+	"
153	+	as_required="as_fn_return () { (exit \$1); }
154	+	as_fn_success () { as_fn_return 0; }
155	+	as_fn_failure () { as_fn_return 1; }
156	+	as_fn_ret_success () { return 0; }
157	+	as_fn_ret_failure () { return 1; }
158
159	+	exitcode=0
160	+	as_fn_success \|\| { exitcode=1; echo as_fn_success failed.; }
161	+	as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
162	+	as_fn_ret_success \|\| { exitcode=1; echo as_fn_ret_success failed.; }
163	+	as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
164	+	if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
165
166	<	# Name of the executable.
167	<	as_me=`$as_basename -- "$0" \|\|
168	<	$as_expr X/"$0" : './$[^/][^/]$/*$' \\| \
169	<	X"$0" : 'X$//$$' \\| \
170	<	X"$0" : 'X$/$' \\| . 2>/dev/null \|\|
171	<	$as_echo X/"$0" \|
172	<	sed '/^.\/$[^/][^/]$\/*$/{
173	<	s//\1/
174	<	q
175	<	}
161	<	/^X\/$\/\/$$/{
162	<	s//\1/
163	<	q
164	<	}
165	<	/^X\/$\/$.*/{
166	<	s//\1/
167	<	q
168	<	}
169	<	s/.*/./; q'`
170	<
171	<	# CDPATH.
172	<	$as_unset CDPATH
173	<
174	<
175	<	if test "x$CONFIG_SHELL" = x; then
176	<	if (eval ":") 2>/dev/null; then
166	>	else
167	>	exitcode=1; echo positional parameters were not saved.
168	>	fi
169	>	test x\$exitcode = x0 \|\| exit 1"
170	>	as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
171	>	as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
172	>	eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
173	>	test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' \|\| exit 1
174	>	test \$(( 1 + 1 )) = 2 \|\| exit 1"
175	>	if (eval "$as_required") 2>/dev/null; then :
176		as_have_required=yes
177		else
178		as_have_required=no
179		fi
180	+	if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
181
182	–	if test $as_have_required = yes && (eval ":
183	–	(as_func_return () {
184	–	(exit \$1)
185	–	}
186	–	as_func_success () {
187	–	as_func_return 0
188	–	}
189	–	as_func_failure () {
190	–	as_func_return 1
191	–	}
192	–	as_func_ret_success () {
193	–	return 0
194	–	}
195	–	as_func_ret_failure () {
196	–	return 1
197	–	}
198	–
199	–	exitcode=0
200	–	if as_func_success; then
201	–	:
182		else
183	<	exitcode=1
184	<	echo as_func_success failed.
205	<	fi
206	<
207	<	if as_func_failure; then
208	<	exitcode=1
209	<	echo as_func_failure succeeded.
210	<	fi
211	<
212	<	if as_func_ret_success; then
213	<	:
214	<	else
215	<	exitcode=1
216	<	echo as_func_ret_success failed.
217	<	fi
218	<
219	<	if as_func_ret_failure; then
220	<	exitcode=1
221	<	echo as_func_ret_failure succeeded.
222	<	fi
223	<
224	<	if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
225	<	:
226	<	else
227	<	exitcode=1
228	<	echo positional parameters were not saved.
229	<	fi
230	<
231	<	test \$exitcode = 0) \|\| { (exit 1); exit 1; }
232	<
233	<	(
234	<	as_lineno_1=\$LINENO
235	<	as_lineno_2=\$LINENO
236	<	test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
237	<	test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") \|\| { (exit 1); exit 1; }
238	<	") 2> /dev/null; then
239	<	:
240	<	else
241	<	as_candidate_shells=
242	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
183	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
184	>	as_found=false
185		for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
186		do
187		IFS=$as_save_IFS
188		test -z "$as_dir" && as_dir=.
189	<	case $as_dir in
189	>	as_found=:
190	>	case $as_dir in #(
191		/*)
192		for as_base in sh bash ksh sh5; do
193	<	as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
193	>	# Try only shells that exist, to save several forks.
194	>	as_shell=$as_dir/$as_base
195	>	if { test -f "$as_shell" \|\| test -f "$as_shell.exe"; } &&
196	>	{ $as_echo "$as_bourne_compatible""$as_required" \| as_run=a "$as_shell"; } 2>/dev/null; then :
197	>	CONFIG_SHELL=$as_shell as_have_required=yes
198	>	if { $as_echo "$as_bourne_compatible""$as_suggested" \| as_run=a "$as_shell"; } 2>/dev/null; then :
199	>	break 2
200	>	fi
201	>	fi
202		done;;
203		esac
204	+	as_found=false
205		done
206	+	$as_found \|\| { if { test -f "$SHELL" \|\| test -f "$SHELL.exe"; } &&
207	+	{ $as_echo "$as_bourne_compatible""$as_required" \| as_run=a "$SHELL"; } 2>/dev/null; then :
208	+	CONFIG_SHELL=$SHELL as_have_required=yes
209	+	fi; }
210		IFS=$as_save_IFS
211
256	–
257	–	for as_shell in $as_candidate_shells $SHELL; do
258	–	# Try only shells that exist, to save several forks.
259	–	if { test -f "$as_shell" \|\| test -f "$as_shell.exe"; } &&
260	–	{ ("$as_shell") 2> /dev/null <<\_ASEOF
261	–	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
262	–	emulate sh
263	–	NULLCMD=:
264	–	# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
265	–	# is contrary to our usage. Disable this feature.
266	–	alias -g '${1+"$@"}'='"$@"'
267	–	setopt NO_GLOB_SUBST
268	–	else
269	–	case `(set -o) 2>/dev/null` in
270	–	posix) set -o posix ;;
271	–	esac
272	–
273	–	fi
274	–
275	–
276	–	:
277	–	_ASEOF
278	–	}; then
279	–	CONFIG_SHELL=$as_shell
280	–	as_have_required=yes
281	–	if { "$as_shell" 2> /dev/null <<\_ASEOF
282	–	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
283	–	emulate sh
284	–	NULLCMD=:
285	–	# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
286	–	# is contrary to our usage. Disable this feature.
287	–	alias -g '${1+"$@"}'='"$@"'
288	–	setopt NO_GLOB_SUBST
289	–	else
290	–	case `(set -o) 2>/dev/null` in
291	–	posix) set -o posix ;;
292	–	esac
293	–
294	–	fi
295	–
296	–
297	–	:
298	–	(as_func_return () {
299	–	(exit $1)
300	–	}
301	–	as_func_success () {
302	–	as_func_return 0
303	–	}
304	–	as_func_failure () {
305	–	as_func_return 1
306	–	}
307	–	as_func_ret_success () {
308	–	return 0
309	–	}
310	–	as_func_ret_failure () {
311	–	return 1
312	–	}
212
213	<	exitcode=0
214	<	if as_func_success; then
215	<	:
216	<	else
217	<	exitcode=1
218	<	echo as_func_success failed.
213	>	if test "x$CONFIG_SHELL" != x; then :
214	>	# We cannot yet assume a decent shell, so we have to provide a
215	>	# neutralization value for shells without unset; and this also
216	>	# works around shells that cannot unset nonexistent variables.
217	>	BASH_ENV=/dev/null
218	>	ENV=/dev/null
219	>	(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
220	>	export CONFIG_SHELL
221	>	exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
222		fi
223
224	<	if as_func_failure; then
225	<	exitcode=1
226	<	echo as_func_failure succeeded.
224	>	if test x$as_have_required = xno; then :
225	>	$as_echo "$0: This script requires a shell more modern than all"
226	>	$as_echo "$0: the shells that I found on your system."
227	>	if test x${ZSH_VERSION+set} = xset ; then
228	>	$as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
229	>	$as_echo "$0: be upgraded to zsh 4.3.4 or later."
230	>	else
231	>	$as_echo "$0: Please tell bug-autoconf@gnu.org and gezelter@nd.edu
232	>	$0: about your system, including any error possibly output
233	>	$0: before this message. Then install a modern shell, or
234	>	$0: manually run the script under such a shell if you do
235	>	$0: have one."
236	>	fi
237	>	exit 1
238		fi
326	–
327	–	if as_func_ret_success; then
328	–	:
329	–	else
330	–	exitcode=1
331	–	echo as_func_ret_success failed.
239		fi
333	–
334	–	if as_func_ret_failure; then
335	–	exitcode=1
336	–	echo as_func_ret_failure succeeded.
240		fi
241	+	SHELL=${CONFIG_SHELL-/bin/sh}
242	+	export SHELL
243	+	# Unset more variables known to interfere with behavior of common tools.
244	+	CLICOLOR_FORCE= GREP_OPTIONS=
245	+	unset CLICOLOR_FORCE GREP_OPTIONS
246
247	<	if ( set x; as_func_ret_success y && test x = "$1" ); then
248	<	:
249	<	else
250	<	exitcode=1
251	<	echo positional parameters were not saved.
252	<	fi
247	>	## --------------------- ##
248	>	## M4sh Shell Functions. ##
249	>	## --------------------- ##
250	>	# as_fn_unset VAR
251	>	# ---------------
252	>	# Portably unset VAR.
253	>	as_fn_unset ()
254	>	{
255	>	{ eval $1=; unset $1;}
256	>	}
257	>	as_unset=as_fn_unset
258
259	<	test $exitcode = 0) \|\| { (exit 1); exit 1; }
259	>	# as_fn_set_status STATUS
260	>	# -----------------------
261	>	# Set $? to STATUS, without forking.
262	>	as_fn_set_status ()
263	>	{
264	>	return $1
265	>	} # as_fn_set_status
266
267	<	(
268	<	as_lineno_1=$LINENO
269	<	as_lineno_2=$LINENO
270	<	test "x$as_lineno_1" != "x$as_lineno_2" &&
271	<	test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") \|\| { (exit 1); exit 1; }
267	>	# as_fn_exit STATUS
268	>	# -----------------
269	>	# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
270	>	as_fn_exit ()
271	>	{
272	>	set +e
273	>	as_fn_set_status $1
274	>	exit $1
275	>	} # as_fn_exit
276
277	<	_ASEOF
278	<	}; then
279	<	break
280	<	fi
277	>	# as_fn_mkdir_p
278	>	# -------------
279	>	# Create "$as_dir" as a directory, including parents if necessary.
280	>	as_fn_mkdir_p ()
281	>	{
282
283	<	fi
283	>	case $as_dir in #(
284	>	-*) as_dir=./$as_dir;;
285	>	esac
286	>	test -d "$as_dir" \|\| eval $as_mkdir_p \|\| {
287	>	as_dirs=
288	>	while :; do
289	>	case $as_dir in #(
290	>	\') as_qdir=`$as_echo "$as_dir" \| sed "s/'/'\\\\\\\\''/g"`;; #'(
291	>	*) as_qdir=$as_dir;;
292	>	esac
293	>	as_dirs="'$as_qdir' $as_dirs"
294	>	as_dir=`$as_dirname -- "$as_dir" \|\|
295	>	$as_expr X"$as_dir" : 'X$.[^/]$//[^/][^/]/$' \\| \
296	>	X"$as_dir" : 'X$//$[^/]' \\| \
297	>	X"$as_dir" : 'X$//$$' \\| \
298	>	X"$as_dir" : 'X$/$' \\| . 2>/dev/null \|\|
299	>	$as_echo X"$as_dir" \|
300	>	sed '/^X$.[^/]$\/\/[^/][^/]\/$/{
301	>	s//\1/
302	>	q
303	>	}
304	>	/^X$\/\/$[^/].*/{
305	>	s//\1/
306	>	q
307	>	}
308	>	/^X$\/\/$$/{
309	>	s//\1/
310	>	q
311	>	}
312	>	/^X$\/$.*/{
313	>	s//\1/
314	>	q
315	>	}
316	>	s/.*/./; q'`
317	>	test -d "$as_dir" && break
318	>	done
319	>	test -z "$as_dirs" \|\| eval "mkdir $as_dirs"
320	>	} \|\| test -d "$as_dir" \|\| as_fn_error "cannot create directory $as_dir"
321
361	–	done
322
323	<	if test "x$CONFIG_SHELL" != x; then
324	<	for as_var in BASH_ENV ENV
325	<	do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
326	<	done
327	<	export CONFIG_SHELL
328	<	exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
329	<	fi
323	>	} # as_fn_mkdir_p
324	>	# as_fn_append VAR VALUE
325	>	# ----------------------
326	>	# Append the text in VALUE to the end of the definition contained in VAR. Take
327	>	# advantage of any shell optimizations that allow amortized linear growth over
328	>	# repeated appends, instead of the typical quadratic growth present in naive
329	>	# implementations.
330	>	if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
331	>	eval 'as_fn_append ()
332	>	{
333	>	eval $1+=\$2
334	>	}'
335	>	else
336	>	as_fn_append ()
337	>	{
338	>	eval $1=\$$1\$2
339	>	}
340	>	fi # as_fn_append
341
342	+	# as_fn_arith ARG...
343	+	# ------------------
344	+	# Perform arithmetic evaluation on the ARGs, and store the result in the
345	+	# global $as_val. Take advantage of shells that can avoid forks. The arguments
346	+	# must be portable across $(()) and expr.
347	+	if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
348	+	eval 'as_fn_arith ()
349	+	{
350	+	as_val=$(( $* ))
351	+	}'
352	+	else
353	+	as_fn_arith ()
354	+	{
355	+	as_val=`expr "$@" \|\| test $? -eq 1`
356	+	}
357	+	fi # as_fn_arith
358
372	–	if test $as_have_required = no; then
373	–	echo This script requires a shell more modern than all the
374	–	echo shells that I found on your system. Please install a
375	–	echo modern shell, or manually run the script under such a
376	–	echo shell if you do have one.
377	–	{ (exit 1); exit 1; }
378	–	fi
359
360	+	# as_fn_error ERROR [LINENO LOG_FD]
361	+	# ---------------------------------
362	+	# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
363	+	# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
364	+	# script with status $?, using 1 if that was 0.
365	+	as_fn_error ()
366	+	{
367	+	as_status=$?; test $as_status -eq 0 && as_status=1
368	+	if test "$3"; then
369	+	as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
370	+	$as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
371	+	fi
372	+	$as_echo "$as_me: error: $1" >&2
373	+	as_fn_exit $as_status
374	+	} # as_fn_error
375
376	<	fi
377	<
378	<	fi
384	<
385	<
386	<
387	<	(eval "as_func_return () {
388	<	(exit \$1)
389	<	}
390	<	as_func_success () {
391	<	as_func_return 0
392	<	}
393	<	as_func_failure () {
394	<	as_func_return 1
395	<	}
396	<	as_func_ret_success () {
397	<	return 0
398	<	}
399	<	as_func_ret_failure () {
400	<	return 1
401	<	}
402	<
403	<	exitcode=0
404	<	if as_func_success; then
405	<	:
376	>	if expr a : '$a$' >/dev/null 2>&1 &&
377	>	test "X`expr 00001 : '.*$...$'`" = X001; then
378	>	as_expr=expr
379		else
380	<	exitcode=1
408	<	echo as_func_success failed.
380	>	as_expr=false
381		fi
382
383	<	if as_func_failure; then
384	<	exitcode=1
413	<	echo as_func_failure succeeded.
414	<	fi
415	<
416	<	if as_func_ret_success; then
417	<	:
383	>	if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
384	>	as_basename=basename
385		else
386	<	exitcode=1
420	<	echo as_func_ret_success failed.
386	>	as_basename=false
387		fi
388
389	<	if as_func_ret_failure; then
390	<	exitcode=1
425	<	echo as_func_ret_failure succeeded.
426	<	fi
427	<
428	<	if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
429	<	:
389	>	if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
390	>	as_dirname=dirname
391		else
392	<	exitcode=1
432	<	echo positional parameters were not saved.
392	>	as_dirname=false
393		fi
394
395	<	test \$exitcode = 0") \|\| {
396	<	echo No shell found that supports shell functions.
397	<	echo Please tell bug-autoconf@gnu.org about your system,
398	<	echo including any error possibly output before this message.
399	<	echo This can help us improve future autoconf versions.
400	<	echo Configuration will now proceed without shell functions.
401	<	}
395	>	as_me=`$as_basename -- "$0" \|\|
396	>	$as_expr X/"$0" : './$[^/][^/]$/*$' \\| \
397	>	X"$0" : 'X$//$$' \\| \
398	>	X"$0" : 'X$/$' \\| . 2>/dev/null \|\|
399	>	$as_echo X/"$0" \|
400	>	sed '/^.\/$[^/][^/]$\/*$/{
401	>	s//\1/
402	>	q
403	>	}
404	>	/^X\/$\/\/$$/{
405	>	s//\1/
406	>	q
407	>	}
408	>	/^X\/$\/$.*/{
409	>	s//\1/
410	>	q
411	>	}
412	>	s/.*/./; q'`
413
414	+	# Avoid depending upon Character Ranges.
415	+	as_cr_letters='abcdefghijklmnopqrstuvwxyz'
416	+	as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
417	+	as_cr_Letters=$as_cr_letters$as_cr_LETTERS
418	+	as_cr_digits='0123456789'
419	+	as_cr_alnum=$as_cr_Letters$as_cr_digits
420
421
422	<	as_lineno_1=$LINENO
423	<	as_lineno_2=$LINENO
424	<	test "x$as_lineno_1" != "x$as_lineno_2" &&
425	<	test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" \|\| {
426	<
450	<	# Create $as_me.lineno as a copy of $as_myself, but with $LINENO
451	<	# uniformly replaced by the line number. The first 'sed' inserts a
452	<	# line-number line after each line using $LINENO; the second 'sed'
453	<	# does the real work. The second script uses 'N' to pair each
454	<	# line-number line with the line containing $LINENO, and appends
455	<	# trailing '-' during substitution so that $LINENO is not a special
456	<	# case at line end.
457	<	# (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
458	<	# scripts with optimization help from Paolo Bonzini. Blame Lee
459	<	# E. McMahon (1931-1989) for sed's syntax. :-)
422	>	as_lineno_1=$LINENO as_lineno_1a=$LINENO
423	>	as_lineno_2=$LINENO as_lineno_2a=$LINENO
424	>	eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
425	>	test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' \|\| {
426	>	# Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
427		sed -n '
428		p
429		/[$]LINENO/=
#	Line 473 \| Line 440 \| test \$exitcode = 0") \|\| {
440		s/-\n.*//
441		' >$as_me.lineno &&
442		chmod +x "$as_me.lineno" \|\|
443	<	{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
477	<	{ (exit 1); exit 1; }; }
443	>	{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
444
445		# Don't try to exec as it changes $[0], causing all sort of problems
446		# (the dirname of $[0] is not the place where we might find the
#	Line 484 \| Line 450 \| test \$exitcode = 0") \|\| {
450		exit
451		}
452
487	–
488	–	if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
489	–	as_dirname=dirname
490	–	else
491	–	as_dirname=false
492	–	fi
493	–
453		ECHO_C= ECHO_N= ECHO_T=
454	<	case `echo -n x` in
454	>	case `echo -n x` in #(((((
455		-n*)
456	<	case `echo 'x\c'` in
456	>	case `echo 'xy\c'` in
457		c) ECHO_T=' ';; # ECHO_T is single tab character.
458	<	*) ECHO_C='\c';;
458	>	xy) ECHO_C='\c';;
459	>	*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
460	>	ECHO_T=' ';;
461		esac;;
462		*)
463		ECHO_N='-n';;
464		esac
504	–	if expr a : '$a$' >/dev/null 2>&1 &&
505	–	test "X`expr 00001 : '.*$...$'`" = X001; then
506	–	as_expr=expr
507	–	else
508	–	as_expr=false
509	–	fi
465
466		rm -f conf$$ conf$$.exe conf$$.file
467		if test -d conf$$.dir; then
#	Line 536 \| Line 491 \| if mkdir -p . 2>/dev/null; then
491		rmdir conf$$.dir 2>/dev/null
492
493		if mkdir -p . 2>/dev/null; then
494	<	as_mkdir_p=:
494	>	as_mkdir_p='mkdir -p "$as_dir"'
495		else
496		test -d ./-p && rmdir ./-p
497		as_mkdir_p=false
#	Line 555 \| Line 510 \| else
510		if test -d "$1"; then
511		test -d "$1/.";
512		else
513	<	case $1 in
513	>	case $1 in #(
514		-*)set "./$1";;
515		esac;
516	<	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
516	>	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
517		???[sx]):;;)false;;esac;fi
518		'\'' sh
519		'
#	Line 572 \| Line 527 \| *as_tr_sh="eval sed 'y%+%pp%;s%[^_$as_cr_alnum]%_%g'"**
527		as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
528
529
575	–
530		exec 7<&0 </dev/null 6>&1
531
532		# Name of the host.
#	Line 591 \| Line 545 \| MAKEFLAGS=
545		subdirs=
546		MFLAGS=
547		MAKEFLAGS=
594	–	SHELL=${CONFIG_SHELL-/bin/sh}
548
549		# Identity of this package.
550		PACKAGE_NAME='OOPSE'
#	Line 599 \| Line 552 \| PACKAGE_BUGREPORT='gezelter@nd.edu'
552		PACKAGE_VERSION='4.0'
553		PACKAGE_STRING='OOPSE 4.0'
554		PACKAGE_BUGREPORT='gezelter@nd.edu'
555	+	PACKAGE_URL=''
556
557		ac_unique_file="src/applications/oopse/oopse.cpp"
558		ac_default_prefix="/usr/local"
#	Line 638 \| Line 592 \| ac_includes_default="\
592		# include <unistd.h>
593		#endif"
594
595	<	ac_subst_vars='SHELL
596	<	PATH_SEPARATOR
597	<	PACKAGE_NAME
598	<	PACKAGE_TARNAME
599	<	PACKAGE_VERSION
600	<	PACKAGE_STRING
601	<	PACKAGE_BUGREPORT
602	<	exec_prefix
603	<	prefix
604	<	program_transform_name
605	<	bindir
606	<	sbindir
607	<	libexecdir
608	<	datarootdir
609	<	datadir
610	<	sysconfdir
611	<	sharedstatedir
612	<	localstatedir
613	<	includedir
614	<	oldincludedir
615	<	docdir
616	<	infodir
617	<	htmldir
618	<	dvidir
619	<	pdfdir
620	<	psdir
621	<	libdir
622	<	localedir
623	<	mandir
624	<	DEFS
625	<	ECHO_C
626	<	ECHO_N
627	<	ECHO_T
628	<	LIBS
629	<	build_alias
630	<	host_alias
631	<	target_alias
632	<	build
633	<	build_cpu
634	<	build_vendor
635	<	build_os
636	<	host
637	<	host_cpu
638	<	host_vendor
639	<	host_os
640	<	PROGNAME
641	<	debug
642	<	USE_SINGLE_PRECISION
643	<	ac_cc_set
644	<	ac_cc_path
645	<	ac_cxx_set
646	<	ac_cxx_path
647	<	ac_fc_set
648	<	ac_fc_path
649	<	acx_mpi_mpicc
650	<	acx_mpi_mpicc_path
651	<	acx_mpi_mpif90
652	<	acx_mpi_mpif90_path
653	<	acx_mpi_mpicxx
700	<	acx_mpi_mpicxx_path
701	<	MPI_CPPFLAGS
702	<	MPI_LIBS
703	<	MPI90_LIBS
595	>	ac_subst_vars='LTLIBOBJS
596	>	SUBDIRS
597	>	OOPSE_HOME
598	>	OOPSE
599	>	MKINSTALLDIRS
600	>	BATEXT
601	>	enable_latex_docs
602	>	enable_html_docs
603	>	enable_dot
604	>	DOC
605	>	DOT
606	>	DOXYGEN
607	>	USE_CGAL
608	>	CGAL_LIBS
609	>	CGAL_LDFLAGS
610	>	CGAL_CPPFLAGS
611	>	CGAL_CXXFLAGS
612	>	CGAL_MAKEFILE
613	>	POW_LIB
614	>	LIBOBJS
615	>	USE_OPENBABEL
616	>	OPENBABEL_LIB
617	>	OPENBABEL_LIB_DIR
618	>	OPENBABEL_INC_DIR
619	>	CXXCPP
620	>	USE_QHULL
621	>	QHULL
622	>	QHULL_LIB_DIR
623	>	QHULL_INC_DIR
624	>	FFTW_LIBS
625	>	FFTW_LIB_DIR
626	>	FFTW_INC_DIR
627	>	ZLIB
628	>	ZLIB_LIB_DIR
629	>	ZLIB_INC_DIR
630	>	F90_MODULE_NAMES
631	>	F90MODINCSPEC
632	>	MODDIRFLAG
633	>	F90_WORK_FILES_ARG
634	>	MOD
635	>	FC_FUNC_
636	>	FC_FUNC
637	>	FCLIBS
638	>	PREPDEFFLAG
639	>	FCFLAGS_SRCEXT
640	>	FCFLAGS_F90
641	>	PS
642	>	AR
643	>	INSTALL_DATA
644	>	INSTALL_SCRIPT
645	>	INSTALL_PROGRAM
646	>	PERL_SHEBANG
647	>	PERLINTERP
648	>	RANLIB
649	>	SET_MAKE
650	>	LN_S
651	>	EGREP
652	>	GREP
653	>	CPP
654		USE_MPI
655	<	CXX
706	<	CXXFLAGS
707	<	LDFLAGS
708	<	CPPFLAGS
709	<	ac_ct_CXX
710	<	EXEEXT
711	<	OBJEXT
712	<	CC
713	<	CFLAGS
714	<	ac_ct_CC
715	<	FC
716	<	FCFLAGS
655	>	MPIFC
656		ac_ct_FC
657	<	CPP
658	<	GREP
659	<	EGREP
660	<	LN_S
661	<	SET_MAKE
662	<	RANLIB
663	<	PERLINTERP
664	<	PERL_SHEBANG
665	<	INSTALL_PROGRAM
666	<	INSTALL_SCRIPT
667	<	INSTALL_DATA
668	<	AR
669	<	PS
670	<	FCFLAGS_F90
671	<	FCFLAGS_SRCEXT
672	<	PREPDEFFLAG
673	<	FCLIBS
674	<	FC_FUNC
675	<	FC_FUNC_
676	<	MOD
677	<	F90_WORK_FILES_ARG
678	<	MODDIRFLAG
679	<	F90MODINCSPEC
680	<	F90_MODULE_NAMES
681	<	ZLIB_INC_DIR
682	<	ZLIB_LIB_DIR
683	<	ZLIB
684	<	FFTW_INC_DIR
685	<	FFTW_LIB_DIR
686	<	FFTW_LIBS
687	<	QHULL_INC_DIR
688	<	QHULL_LIB_DIR
689	<	QHULL
690	<	USE_QHULL
691	<	CXXCPP
692	<	OPENBABEL_INC_DIR
693	<	OPENBABEL_LIB_DIR
694	<	OPENBABEL_LIB
695	<	USE_OPENBABEL
696	<	LIBOBJS
697	<	POW_LIB
698	<	CGAL_MAKEFILE
699	<	CGAL_CXXFLAGS
700	<	CGAL_CPPFLAGS
701	<	CGAL_LDFLAGS
702	<	CGAL_LIBS
703	<	USE_CGAL
704	<	DOXYGEN
705	<	DOT
706	<	DOC
707	<	enable_dot
708	<	enable_html_docs
709	<	enable_latex_docs
710	<	BATEXT
711	<	MKINSTALLDIRS
712	<	OOPSE
713	<	OOPSE_HOME
714	<	SUBDIRS
715	<	LTLIBOBJS'
657	>	FCFLAGS
658	>	FC
659	>	MPICC
660	>	ac_ct_CC
661	>	CFLAGS
662	>	CC
663	>	MPILIBS
664	>	MPICXX
665	>	OBJEXT
666	>	EXEEXT
667	>	ac_ct_CXX
668	>	CPPFLAGS
669	>	LDFLAGS
670	>	CXXFLAGS
671	>	CXX
672	>	ac_fc_path
673	>	ac_fc_set
674	>	ac_cxx_path
675	>	ac_cxx_set
676	>	ac_cc_path
677	>	ac_cc_set
678	>	USE_SINGLE_PRECISION
679	>	debug
680	>	PROGNAME
681	>	host_os
682	>	host_vendor
683	>	host_cpu
684	>	host
685	>	build_os
686	>	build_vendor
687	>	build_cpu
688	>	build
689	>	target_alias
690	>	host_alias
691	>	build_alias
692	>	LIBS
693	>	ECHO_T
694	>	ECHO_N
695	>	ECHO_C
696	>	DEFS
697	>	mandir
698	>	localedir
699	>	libdir
700	>	psdir
701	>	pdfdir
702	>	dvidir
703	>	htmldir
704	>	infodir
705	>	docdir
706	>	oldincludedir
707	>	includedir
708	>	localstatedir
709	>	sharedstatedir
710	>	sysconfdir
711	>	datadir
712	>	datarootdir
713	>	libexecdir
714	>	sbindir
715	>	bindir
716	>	program_transform_name
717	>	prefix
718	>	exec_prefix
719	>	PACKAGE_URL
720	>	PACKAGE_BUGREPORT
721	>	PACKAGE_STRING
722	>	PACKAGE_VERSION
723	>	PACKAGE_TARNAME
724	>	PACKAGE_NAME
725	>	PATH_SEPARATOR
726	>	SHELL'
727		ac_subst_files=''
728		ac_user_opts='
729		enable_option_checking
#	Line 781 \| Line 731 \| enable_float
731		enable_debug
732		enable_single
733		enable_float
784	–	with_mpi
734		with_perl_shebang
735		with_zlib
736		with_fftw
#	Line 802 \| Line 751 \| CCC
751		LIBS
752		CPPFLAGS
753		CCC
754	+	MPICXX
755		CC
756		CFLAGS
757	+	MPICC
758		FC
759		FCFLAGS
760	+	MPIFC
761		CPP
762		CXXCPP'
763
#	Line 916 \| Line 868 \| do
868		ac_useropt=`expr "x$ac_option" : 'x-disable-$.$'`
869		# Reject names that are not valid shell variable names.
870		expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
871	<	{ $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
920	<	{ (exit 1); exit 1; }; }
871	>	as_fn_error "invalid feature name: $ac_useropt"
872		ac_useropt_orig=$ac_useropt
873		ac_useropt=`$as_echo "$ac_useropt" \| sed 's/[-+.]/_/g'`
874		case $ac_user_opts in
#	Line 943 \| Line 894 \| do
894		ac_useropt=`expr "x$ac_option" : 'x-enable-$[^=]$'`
895		# Reject names that are not valid shell variable names.
896		expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
897	<	{ $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
947	<	{ (exit 1); exit 1; }; }
897	>	as_fn_error "invalid feature name: $ac_useropt"
898		ac_useropt_orig=$ac_useropt
899		ac_useropt=`$as_echo "$ac_useropt" \| sed 's/[-+.]/_/g'`
900		case $ac_user_opts in
#	Line 1148 \| Line 1098 \| do
1098		ac_useropt=`expr "x$ac_option" : 'x-with-$[^=]$'`
1099		# Reject names that are not valid shell variable names.
1100		expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1101	<	{ $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1152	<	{ (exit 1); exit 1; }; }
1101	>	as_fn_error "invalid package name: $ac_useropt"
1102		ac_useropt_orig=$ac_useropt
1103		ac_useropt=`$as_echo "$ac_useropt" \| sed 's/[-+.]/_/g'`
1104		case $ac_user_opts in
#	Line 1165 \| Line 1114 \| do
1114		ac_useropt=`expr "x$ac_option" : 'x-without-$.$'`
1115		# Reject names that are not valid shell variable names.
1116		expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1117	<	{ $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1169	<	{ (exit 1); exit 1; }; }
1117	>	as_fn_error "invalid package name: $ac_useropt"
1118		ac_useropt_orig=$ac_useropt
1119		ac_useropt=`$as_echo "$ac_useropt" \| sed 's/[-+.]/_/g'`
1120		case $ac_user_opts in
#	Line 1196 \| Line 1144 \| do
1144		\| --x-librar=* \| --x-libra=* \| --x-libr=* \| --x-lib=* \| --x-li=* \| --x-l=*)
1145		x_libraries=$ac_optarg ;;
1146
1147	<	-*) { $as_echo "$as_me: error: unrecognized option: $ac_option
1148	<	Try \`$0 --help' for more information." >&2
1201	<	{ (exit 1); exit 1; }; }
1147	>	-*) as_fn_error "unrecognized option: \`$ac_option'
1148	>	Try \`$0 --help' for more information."
1149		;;
1150
1151		=)
1152		ac_envvar=`expr "x$ac_option" : 'x$[^=]*$='`
1153		# Reject names that are not valid shell variable names.
1154	<	expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
1155	<	{ $as_echo "$as_me: error: invalid variable name: $ac_envvar" >&2
1156	<	{ (exit 1); exit 1; }; }
1154	>	case $ac_envvar in #(
1155	>	'' \| [0-9]* \| [!_$as_cr_alnum] )
1156	>	as_fn_error "invalid variable name: \`$ac_envvar'" ;;
1157	>	esac
1158		eval $ac_envvar=\$ac_optarg
1159		export $ac_envvar ;;
1160
#	Line 1223 \| Line 1171 \| if test -n "$ac_prev"; then
1171
1172		if test -n "$ac_prev"; then
1173		ac_option=--`echo $ac_prev \| sed 's/_/-/g'`
1174	<	{ $as_echo "$as_me: error: missing argument to $ac_option" >&2
1227	<	{ (exit 1); exit 1; }; }
1174	>	as_fn_error "missing argument to $ac_option"
1175		fi
1176
1177		if test -n "$ac_unrecognized_opts"; then
1178		case $enable_option_checking in
1179		no) ;;
1180	<	fatal) { $as_echo "$as_me: error: Unrecognized options: $ac_unrecognized_opts" >&2
1181	<	{ (exit 1); exit 1; }; } ;;
1235	<	*) $as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2 ;;
1180	>	fatal) as_fn_error "unrecognized options: $ac_unrecognized_opts" ;;
1181	>	*) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1182		esac
1183		fi
1184
#	Line 1254 \| Line 1200 \| do
1200		[\\/$]* \| ?:[\\/]* ) continue;;
1201		NONE \| '' ) case $ac_var in *prefix ) continue;; esac;;
1202		esac
1203	<	{ $as_echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
1258	<	{ (exit 1); exit 1; }; }
1203	>	as_fn_error "expected an absolute directory name for --$ac_var: $ac_val"
1204		done
1205
1206		# There might be people who depend on the old broken behavior: `$host'
#	Line 1285 \| Line 1230 \| ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` \|\|
1230		ac_pwd=`pwd` && test -n "$ac_pwd" &&
1231		ac_ls_di=`ls -di .` &&
1232		ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` \|\|
1233	<	{ $as_echo "$as_me: error: Working directory cannot be determined" >&2
1289	<	{ (exit 1); exit 1; }; }
1233	>	as_fn_error "working directory cannot be determined"
1234		test "X$ac_ls_di" = "X$ac_pwd_ls_di" \|\|
1235	<	{ $as_echo "$as_me: error: pwd does not report name of working directory" >&2
1292	<	{ (exit 1); exit 1; }; }
1235	>	as_fn_error "pwd does not report name of working directory"
1236
1237
1238		# Find the source files, if location was not specified.
#	Line 1328 \| Line 1271 \| if test ! -r "$srcdir/$ac_unique_file"; then
1271		fi
1272		if test ! -r "$srcdir/$ac_unique_file"; then
1273		test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1274	<	{ $as_echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
1332	<	{ (exit 1); exit 1; }; }
1274	>	as_fn_error "cannot find sources ($ac_unique_file) in $srcdir"
1275		fi
1276		ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1277		ac_abs_confdir=`(
1278	<	cd "$srcdir" && test -r "./$ac_unique_file" \|\| { $as_echo "$as_me: error: $ac_msg" >&2
1337	<	{ (exit 1); exit 1; }; }
1278	>	cd "$srcdir" && test -r "./$ac_unique_file" \|\| as_fn_error "$ac_msg"
1279		pwd)`
1280		# When building in place, set srcdir=.
1281		if test "$ac_abs_confdir" = "$ac_pwd"; then
#	Line 1445 \| Line 1386 \| Optional Packages:
1386		Optional Packages:
1387		--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
1388		--without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
1448	–	--with-mpi=auto\|mpich\|lam\|openmpi\|no
1449	–	Indicates which kind of MPI implementation to use
1450	–	[default=auto]
1389		--with-perl-shebang override what perl thinks is the way for the kernel
1390		to start it (seldom needed)
1391		--with-zlib=DIR root directory path of zlib installation (defaults
#	Line 1470 \| Line 1408 \| Some influential environment variables:
1408		LIBS libraries to pass to the linker, e.g. -l<library>
1409		CPPFLAGS C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1410		you have headers in a nonstandard directory <include dir>
1411	+	MPICXX MPI C++ compiler command
1412		CC C compiler command
1413		CFLAGS C compiler flags
1414	+	MPICC MPI C compiler command
1415		FC Fortran compiler command
1416		FCFLAGS Fortran compiler flags
1417	+	MPIFC MPI Fortran compiler command
1418		CPP C preprocessor
1419		CXXCPP C++ preprocessor
1420
#	Line 1544 \| Line 1485 \| OOPSE configure 4.0
1485		if $ac_init_version; then
1486		cat <<\_ACEOF
1487		OOPSE configure 4.0
1488	<	generated by GNU Autoconf 2.62
1488	>	generated by GNU Autoconf 2.64
1489
1490	<	Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1550	<	2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
1490	>	Copyright (C) 2009 Free Software Foundation, Inc.
1491		This configure script is free software; the Free Software Foundation
1492		gives unlimited permission to copy, distribute and modify it.
1493		_ACEOF
1494		exit
1495		fi
1556	–	cat >config.log <<_ACEOF
1557	–	This file contains any messages produced by compilers while
1558	–	running configure, to aid debugging if configure makes a mistake.
1496
1497	<	It was created by OOPSE $as_me 4.0, which was
1498	<	generated by GNU Autoconf 2.62. Invocation command line was
1497	>	## ------------------------ ##
1498	>	## Autoconf initialization. ##
1499	>	## ------------------------ ##
1500
1501	<	$ $0 $@
1502	<
1503	<	_ACEOF
1504	<	exec 5>>config.log
1501	>	# ac_fn_cxx_try_compile LINENO
1502	>	# ----------------------------
1503	>	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1504	>	ac_fn_cxx_try_compile ()
1505		{
1506	<	cat <<_ASUNAME
1507	<	## --------- ##
1508	<	## Platform. ##
1509	<	## --------- ##
1510	<
1511	<	hostname = `(hostname \|\| uname -n) 2>/dev/null \| sed 1q`
1512	<	uname -m = `(uname -m) 2>/dev/null \|\| echo unknown`
1513	<	uname -r = `(uname -r) 2>/dev/null \|\| echo unknown`
1514	<	uname -s = `(uname -s) 2>/dev/null \|\| echo unknown`
1515	<	uname -v = `(uname -v) 2>/dev/null \|\| echo unknown`
1516	<
1517	<	/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null \|\| echo unknown`
1518	<	/bin/uname -X = `(/bin/uname -X) 2>/dev/null \|\| echo unknown`
1506	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1507	>	rm -f conftest.$ac_objext
1508	>	if { { ac_try="$ac_compile"
1509	>	case "(($ac_try" in
1510	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
1511	>	*) ac_try_echo=$ac_try;;
1512	>	esac
1513	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1514	>	$as_echo "$ac_try_echo"; } >&5
1515	>	(eval "$ac_compile") 2>conftest.err
1516	>	ac_status=$?
1517	>	if test -s conftest.err; then
1518	>	grep -v '^ *+' conftest.err >conftest.er1
1519	>	cat conftest.er1 >&5
1520	>	mv -f conftest.er1 conftest.err
1521	>	fi
1522	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1523	>	test $ac_status = 0; } && {
1524	>	test -z "$ac_cxx_werror_flag" \|\|
1525	>	test ! -s conftest.err
1526	>	} && test -s conftest.$ac_objext; then :
1527	>	ac_retval=0
1528	>	else
1529	>	$as_echo "$as_me: failed program was:" >&5
1530	>	sed 's/^/\| /' conftest.$ac_ext >&5
1531
1532	<	/bin/arch = `(/bin/arch) 2>/dev/null \|\| echo unknown`
1533	<	/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null \|\| echo unknown`
1534	<	/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null \|\| echo unknown`
1535	<	/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null \|\| echo unknown`
1586	<	/bin/machine = `(/bin/machine) 2>/dev/null \|\| echo unknown`
1587	<	/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null \|\| echo unknown`
1588	<	/bin/universe = `(/bin/universe) 2>/dev/null \|\| echo unknown`
1532	>	ac_retval=1
1533	>	fi
1534	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1535	>	return $ac_retval
1536
1537	<	_ASUNAME
1537	>	} # ac_fn_cxx_try_compile
1538
1539	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1540	<	for as_dir in $PATH
1541	<	do
1542	<	IFS=$as_save_IFS
1543	<	test -z "$as_dir" && as_dir=.
1544	<	$as_echo "PATH: $as_dir"
1545	<	done
1546	<	IFS=$as_save_IFS
1547	<
1548	<	} >&5
1549	<
1550	<	cat >&5 <<_ACEOF
1551	<
1552	<
1553	<	## ----------- ##
1554	<	## Core tests. ##
1555	<	## ----------- ##
1556	<
1557	<	_ACEOF
1558	<
1559	<
1560	<	# Keep a trace of the command line.
1539	>	# ac_fn_cxx_try_link LINENO
1540	>	# -------------------------
1541	>	# Try to link conftest.$ac_ext, and return whether this succeeded.
1542	>	ac_fn_cxx_try_link ()
1543	>	{
1544	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1545	>	rm -f conftest.$ac_objext conftest$ac_exeext
1546	>	if { { ac_try="$ac_link"
1547	>	case "(($ac_try" in
1548	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
1549	>	*) ac_try_echo=$ac_try;;
1550	>	esac
1551	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1552	>	$as_echo "$ac_try_echo"; } >&5
1553	>	(eval "$ac_link") 2>conftest.err
1554	>	ac_status=$?
1555	>	if test -s conftest.err; then
1556	>	grep -v '^ *+' conftest.err >conftest.er1
1557	>	cat conftest.er1 >&5
1558	>	mv -f conftest.er1 conftest.err
1559	>	fi
1560	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1561	>	test $ac_status = 0; } && {
1562	>	test -z "$ac_cxx_werror_flag" \|\|
1563	>	test ! -s conftest.err
1564	>	} && test -s conftest$ac_exeext && {
1565	>	test "$cross_compiling" = yes \|\|
1566	>	$as_test_x conftest$ac_exeext
1567	>	}; then :
1568	>	ac_retval=0
1569	>	else
1570	>	$as_echo "$as_me: failed program was:" >&5
1571	>	sed 's/^/\| /' conftest.$ac_ext >&5
1572	>
1573	>	ac_retval=1
1574	>	fi
1575	>	# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1576	>	# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1577	>	# interfere with the next link command; also delete a directory that is
1578	>	# left behind by Apple's compiler. We do this before executing the actions.
1579	>	rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1580	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1581	>	return $ac_retval
1582	>
1583	>	} # ac_fn_cxx_try_link
1584	>
1585	>	# ac_fn_cxx_check_func LINENO FUNC VAR
1586	>	# ------------------------------------
1587	>	# Tests whether FUNC exists, setting the cache variable VAR accordingly
1588	>	ac_fn_cxx_check_func ()
1589	>	{
1590	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1591	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1592	>	$as_echo_n "checking for $2... " >&6; }
1593	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1594	>	$as_echo_n "(cached) " >&6
1595	>	else
1596	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1597	>	/* end confdefs.h. */
1598	>	/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1599	>	For example, HP-UX 11i <limits.h> declares gettimeofday. */
1600	>	#define $2 innocuous_$2
1601	>
1602	>	/* System header to define __stub macros and hopefully few prototypes,
1603	>	which can conflict with char $2 (); below.
1604	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1605	>	<limits.h> exists even on freestanding compilers. */
1606	>
1607	>	#ifdef __STDC__
1608	>	# include <limits.h>
1609	>	#else
1610	>	# include <assert.h>
1611	>	#endif
1612	>
1613	>	#undef $2
1614	>
1615	>	/* Override any GCC internal prototype to avoid an error.
1616	>	Use char because int might match the return type of a GCC
1617	>	builtin and then its argument prototype would still apply. */
1618	>	#ifdef __cplusplus
1619	>	extern "C"
1620	>	#endif
1621	>	char $2 ();
1622	>	/* The GNU C library defines this for functions which it implements
1623	>	to always fail with ENOSYS. Some functions are actually named
1624	>	something starting with __ and the normal name is an alias. */
1625	>	#if defined __stub_$2 \|\| defined __stub___$2
1626	>	choke me
1627	>	#endif
1628	>
1629	>	int
1630	>	main ()
1631	>	{
1632	>	return $2 ();
1633	>	;
1634	>	return 0;
1635	>	}
1636	>	_ACEOF
1637	>	if ac_fn_cxx_try_link "$LINENO"; then :
1638	>	eval "$3=yes"
1639	>	else
1640	>	eval "$3=no"
1641	>	fi
1642	>	rm -f core conftest.err conftest.$ac_objext \
1643	>	conftest$ac_exeext conftest.$ac_ext
1644	>	fi
1645	>	eval ac_res=\$$3
1646	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1647	>	$as_echo "$ac_res" >&6; }
1648	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1649	>
1650	>	} # ac_fn_cxx_check_func
1651	>
1652	>	# ac_fn_c_try_compile LINENO
1653	>	# --------------------------
1654	>	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1655	>	ac_fn_c_try_compile ()
1656	>	{
1657	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1658	>	rm -f conftest.$ac_objext
1659	>	if { { ac_try="$ac_compile"
1660	>	case "(($ac_try" in
1661	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
1662	>	*) ac_try_echo=$ac_try;;
1663	>	esac
1664	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1665	>	$as_echo "$ac_try_echo"; } >&5
1666	>	(eval "$ac_compile") 2>conftest.err
1667	>	ac_status=$?
1668	>	if test -s conftest.err; then
1669	>	grep -v '^ *+' conftest.err >conftest.er1
1670	>	cat conftest.er1 >&5
1671	>	mv -f conftest.er1 conftest.err
1672	>	fi
1673	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1674	>	test $ac_status = 0; } && {
1675	>	test -z "$ac_c_werror_flag" \|\|
1676	>	test ! -s conftest.err
1677	>	} && test -s conftest.$ac_objext; then :
1678	>	ac_retval=0
1679	>	else
1680	>	$as_echo "$as_me: failed program was:" >&5
1681	>	sed 's/^/\| /' conftest.$ac_ext >&5
1682	>
1683	>	ac_retval=1
1684	>	fi
1685	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1686	>	return $ac_retval
1687	>
1688	>	} # ac_fn_c_try_compile
1689	>
1690	>	# ac_fn_c_try_link LINENO
1691	>	# -----------------------
1692	>	# Try to link conftest.$ac_ext, and return whether this succeeded.
1693	>	ac_fn_c_try_link ()
1694	>	{
1695	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1696	>	rm -f conftest.$ac_objext conftest$ac_exeext
1697	>	if { { ac_try="$ac_link"
1698	>	case "(($ac_try" in
1699	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
1700	>	*) ac_try_echo=$ac_try;;
1701	>	esac
1702	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1703	>	$as_echo "$ac_try_echo"; } >&5
1704	>	(eval "$ac_link") 2>conftest.err
1705	>	ac_status=$?
1706	>	if test -s conftest.err; then
1707	>	grep -v '^ *+' conftest.err >conftest.er1
1708	>	cat conftest.er1 >&5
1709	>	mv -f conftest.er1 conftest.err
1710	>	fi
1711	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1712	>	test $ac_status = 0; } && {
1713	>	test -z "$ac_c_werror_flag" \|\|
1714	>	test ! -s conftest.err
1715	>	} && test -s conftest$ac_exeext && {
1716	>	test "$cross_compiling" = yes \|\|
1717	>	$as_test_x conftest$ac_exeext
1718	>	}; then :
1719	>	ac_retval=0
1720	>	else
1721	>	$as_echo "$as_me: failed program was:" >&5
1722	>	sed 's/^/\| /' conftest.$ac_ext >&5
1723	>
1724	>	ac_retval=1
1725	>	fi
1726	>	# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1727	>	# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1728	>	# interfere with the next link command; also delete a directory that is
1729	>	# left behind by Apple's compiler. We do this before executing the actions.
1730	>	rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1731	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1732	>	return $ac_retval
1733	>
1734	>	} # ac_fn_c_try_link
1735	>
1736	>	# ac_fn_c_check_func LINENO FUNC VAR
1737	>	# ----------------------------------
1738	>	# Tests whether FUNC exists, setting the cache variable VAR accordingly
1739	>	ac_fn_c_check_func ()
1740	>	{
1741	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1742	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1743	>	$as_echo_n "checking for $2... " >&6; }
1744	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1745	>	$as_echo_n "(cached) " >&6
1746	>	else
1747	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1748	>	/* end confdefs.h. */
1749	>	/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1750	>	For example, HP-UX 11i <limits.h> declares gettimeofday. */
1751	>	#define $2 innocuous_$2
1752	>
1753	>	/* System header to define __stub macros and hopefully few prototypes,
1754	>	which can conflict with char $2 (); below.
1755	>	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1756	>	<limits.h> exists even on freestanding compilers. */
1757	>
1758	>	#ifdef __STDC__
1759	>	# include <limits.h>
1760	>	#else
1761	>	# include <assert.h>
1762	>	#endif
1763	>
1764	>	#undef $2
1765	>
1766	>	/* Override any GCC internal prototype to avoid an error.
1767	>	Use char because int might match the return type of a GCC
1768	>	builtin and then its argument prototype would still apply. */
1769	>	#ifdef __cplusplus
1770	>	extern "C"
1771	>	#endif
1772	>	char $2 ();
1773	>	/* The GNU C library defines this for functions which it implements
1774	>	to always fail with ENOSYS. Some functions are actually named
1775	>	something starting with __ and the normal name is an alias. */
1776	>	#if defined __stub_$2 \|\| defined __stub___$2
1777	>	choke me
1778	>	#endif
1779	>
1780	>	int
1781	>	main ()
1782	>	{
1783	>	return $2 ();
1784	>	;
1785	>	return 0;
1786	>	}
1787	>	_ACEOF
1788	>	if ac_fn_c_try_link "$LINENO"; then :
1789	>	eval "$3=yes"
1790	>	else
1791	>	eval "$3=no"
1792	>	fi
1793	>	rm -f core conftest.err conftest.$ac_objext \
1794	>	conftest$ac_exeext conftest.$ac_ext
1795	>	fi
1796	>	eval ac_res=\$$3
1797	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1798	>	$as_echo "$ac_res" >&6; }
1799	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1800	>
1801	>	} # ac_fn_c_check_func
1802	>
1803	>	# ac_fn_fc_try_compile LINENO
1804	>	# ---------------------------
1805	>	# Try to compile conftest.$ac_ext, and return whether this succeeded.
1806	>	ac_fn_fc_try_compile ()
1807	>	{
1808	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1809	>	rm -f conftest.$ac_objext
1810	>	if { { ac_try="$ac_compile"
1811	>	case "(($ac_try" in
1812	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
1813	>	*) ac_try_echo=$ac_try;;
1814	>	esac
1815	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1816	>	$as_echo "$ac_try_echo"; } >&5
1817	>	(eval "$ac_compile") 2>conftest.err
1818	>	ac_status=$?
1819	>	if test -s conftest.err; then
1820	>	grep -v '^ *+' conftest.err >conftest.er1
1821	>	cat conftest.er1 >&5
1822	>	mv -f conftest.er1 conftest.err
1823	>	fi
1824	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1825	>	test $ac_status = 0; } && {
1826	>	test -z "$ac_fc_werror_flag" \|\|
1827	>	test ! -s conftest.err
1828	>	} && test -s conftest.$ac_objext; then :
1829	>	ac_retval=0
1830	>	else
1831	>	$as_echo "$as_me: failed program was:" >&5
1832	>	sed 's/^/\| /' conftest.$ac_ext >&5
1833	>
1834	>	ac_retval=1
1835	>	fi
1836	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1837	>	return $ac_retval
1838	>
1839	>	} # ac_fn_fc_try_compile
1840	>
1841	>	# ac_fn_fc_try_link LINENO
1842	>	# ------------------------
1843	>	# Try to link conftest.$ac_ext, and return whether this succeeded.
1844	>	ac_fn_fc_try_link ()
1845	>	{
1846	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1847	>	rm -f conftest.$ac_objext conftest$ac_exeext
1848	>	if { { ac_try="$ac_link"
1849	>	case "(($ac_try" in
1850	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
1851	>	*) ac_try_echo=$ac_try;;
1852	>	esac
1853	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1854	>	$as_echo "$ac_try_echo"; } >&5
1855	>	(eval "$ac_link") 2>conftest.err
1856	>	ac_status=$?
1857	>	if test -s conftest.err; then
1858	>	grep -v '^ *+' conftest.err >conftest.er1
1859	>	cat conftest.er1 >&5
1860	>	mv -f conftest.er1 conftest.err
1861	>	fi
1862	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1863	>	test $ac_status = 0; } && {
1864	>	test -z "$ac_fc_werror_flag" \|\|
1865	>	test ! -s conftest.err
1866	>	} && test -s conftest$ac_exeext && {
1867	>	test "$cross_compiling" = yes \|\|
1868	>	$as_test_x conftest$ac_exeext
1869	>	}; then :
1870	>	ac_retval=0
1871	>	else
1872	>	$as_echo "$as_me: failed program was:" >&5
1873	>	sed 's/^/\| /' conftest.$ac_ext >&5
1874	>
1875	>	ac_retval=1
1876	>	fi
1877	>	# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1878	>	# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1879	>	# interfere with the next link command; also delete a directory that is
1880	>	# left behind by Apple's compiler. We do this before executing the actions.
1881	>	rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1882	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1883	>	return $ac_retval
1884	>
1885	>	} # ac_fn_fc_try_link
1886	>
1887	>	# ac_fn_c_try_cpp LINENO
1888	>	# ----------------------
1889	>	# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1890	>	ac_fn_c_try_cpp ()
1891	>	{
1892	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1893	>	if { { ac_try="$ac_cpp conftest.$ac_ext"
1894	>	case "(($ac_try" in
1895	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
1896	>	*) ac_try_echo=$ac_try;;
1897	>	esac
1898	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1899	>	$as_echo "$ac_try_echo"; } >&5
1900	>	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1901	>	ac_status=$?
1902	>	if test -s conftest.err; then
1903	>	grep -v '^ *+' conftest.err >conftest.er1
1904	>	cat conftest.er1 >&5
1905	>	mv -f conftest.er1 conftest.err
1906	>	fi
1907	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1908	>	test $ac_status = 0; } >/dev/null && {
1909	>	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
1910	>	test ! -s conftest.err
1911	>	}; then :
1912	>	ac_retval=0
1913	>	else
1914	>	$as_echo "$as_me: failed program was:" >&5
1915	>	sed 's/^/\| /' conftest.$ac_ext >&5
1916	>
1917	>	ac_retval=1
1918	>	fi
1919	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1920	>	return $ac_retval
1921	>
1922	>	} # ac_fn_c_try_cpp
1923	>
1924	>	# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1925	>	# -------------------------------------------------------
1926	>	# Tests whether HEADER exists, giving a warning if it cannot be compiled using
1927	>	# the include files in INCLUDES and setting the cache variable VAR
1928	>	# accordingly.
1929	>	ac_fn_c_check_header_mongrel ()
1930	>	{
1931	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1932	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1933	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1934	>	$as_echo_n "checking for $2... " >&6; }
1935	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1936	>	$as_echo_n "(cached) " >&6
1937	>	fi
1938	>	eval ac_res=\$$3
1939	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1940	>	$as_echo "$ac_res" >&6; }
1941	>	else
1942	>	# Is the header compilable?
1943	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1944	>	$as_echo_n "checking $2 usability... " >&6; }
1945	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1946	>	/* end confdefs.h. */
1947	>	$4
1948	>	#include <$2>
1949	>	_ACEOF
1950	>	if ac_fn_c_try_compile "$LINENO"; then :
1951	>	ac_header_compiler=yes
1952	>	else
1953	>	ac_header_compiler=no
1954	>	fi
1955	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1956	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1957	>	$as_echo "$ac_header_compiler" >&6; }
1958	>
1959	>	# Is the header present?
1960	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1961	>	$as_echo_n "checking $2 presence... " >&6; }
1962	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1963	>	/* end confdefs.h. */
1964	>	#include <$2>
1965	>	_ACEOF
1966	>	if ac_fn_c_try_cpp "$LINENO"; then :
1967	>	ac_header_preproc=yes
1968	>	else
1969	>	ac_header_preproc=no
1970	>	fi
1971	>	rm -f conftest.err conftest.$ac_ext
1972	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1973	>	$as_echo "$ac_header_preproc" >&6; }
1974	>
1975	>	# So? What about this header?
1976	>	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1977	>	yes:no: )
1978	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1979	>	$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1980	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1981	>	$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1982	>	;;
1983	>	no:yes:* )
1984	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1985	>	$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1986	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
1987	>	$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
1988	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1989	>	$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1990	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
1991	>	$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
1992	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1993	>	$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1994	>	( cat <<\_ASBOX
1995	>	## ------------------------------ ##
1996	>	## Report this to gezelter@nd.edu ##
1997	>	## ------------------------------ ##
1998	>	_ASBOX
1999	>	) \| sed "s/^/$as_me: WARNING: /" >&2
2000	>	;;
2001	>	esac
2002	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2003	>	$as_echo_n "checking for $2... " >&6; }
2004	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2005	>	$as_echo_n "(cached) " >&6
2006	>	else
2007	>	eval "$3=\$ac_header_compiler"
2008	>	fi
2009	>	eval ac_res=\$$3
2010	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2011	>	$as_echo "$ac_res" >&6; }
2012	>	fi
2013	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2014	>
2015	>	} # ac_fn_c_check_header_mongrel
2016	>
2017	>	# ac_fn_c_try_run LINENO
2018	>	# ----------------------
2019	>	# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2020	>	# that executables can be run.
2021	>	ac_fn_c_try_run ()
2022	>	{
2023	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2024	>	if { { ac_try="$ac_link"
2025	>	case "(($ac_try" in
2026	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
2027	>	*) ac_try_echo=$ac_try;;
2028	>	esac
2029	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2030	>	$as_echo "$ac_try_echo"; } >&5
2031	>	(eval "$ac_link") 2>&5
2032	>	ac_status=$?
2033	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2034	>	test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2035	>	{ { case "(($ac_try" in
2036	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
2037	>	*) ac_try_echo=$ac_try;;
2038	>	esac
2039	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2040	>	$as_echo "$ac_try_echo"; } >&5
2041	>	(eval "$ac_try") 2>&5
2042	>	ac_status=$?
2043	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2044	>	test $ac_status = 0; }; }; then :
2045	>	ac_retval=0
2046	>	else
2047	>	$as_echo "$as_me: program exited with status $ac_status" >&5
2048	>	$as_echo "$as_me: failed program was:" >&5
2049	>	sed 's/^/\| /' conftest.$ac_ext >&5
2050	>
2051	>	ac_retval=$ac_status
2052	>	fi
2053	>	rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2054	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2055	>	return $ac_retval
2056	>
2057	>	} # ac_fn_c_try_run
2058	>
2059	>	# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2060	>	# -------------------------------------------------------
2061	>	# Tests whether HEADER exists and can be compiled using the include files in
2062	>	# INCLUDES, setting the cache variable VAR accordingly.
2063	>	ac_fn_c_check_header_compile ()
2064	>	{
2065	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2066	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2067	>	$as_echo_n "checking for $2... " >&6; }
2068	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2069	>	$as_echo_n "(cached) " >&6
2070	>	else
2071	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2072	>	/* end confdefs.h. */
2073	>	$4
2074	>	#include <$2>
2075	>	_ACEOF
2076	>	if ac_fn_c_try_compile "$LINENO"; then :
2077	>	eval "$3=yes"
2078	>	else
2079	>	eval "$3=no"
2080	>	fi
2081	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2082	>	fi
2083	>	eval ac_res=\$$3
2084	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2085	>	$as_echo "$ac_res" >&6; }
2086	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2087	>
2088	>	} # ac_fn_c_check_header_compile
2089	>
2090	>	# ac_fn_cxx_try_cpp LINENO
2091	>	# ------------------------
2092	>	# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2093	>	ac_fn_cxx_try_cpp ()
2094	>	{
2095	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2096	>	if { { ac_try="$ac_cpp conftest.$ac_ext"
2097	>	case "(($ac_try" in
2098	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
2099	>	*) ac_try_echo=$ac_try;;
2100	>	esac
2101	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2102	>	$as_echo "$ac_try_echo"; } >&5
2103	>	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2104	>	ac_status=$?
2105	>	if test -s conftest.err; then
2106	>	grep -v '^ *+' conftest.err >conftest.er1
2107	>	cat conftest.er1 >&5
2108	>	mv -f conftest.er1 conftest.err
2109	>	fi
2110	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2111	>	test $ac_status = 0; } >/dev/null && {
2112	>	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" \|\|
2113	>	test ! -s conftest.err
2114	>	}; then :
2115	>	ac_retval=0
2116	>	else
2117	>	$as_echo "$as_me: failed program was:" >&5
2118	>	sed 's/^/\| /' conftest.$ac_ext >&5
2119	>
2120	>	ac_retval=1
2121	>	fi
2122	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2123	>	return $ac_retval
2124	>
2125	>	} # ac_fn_cxx_try_cpp
2126	>
2127	>	# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2128	>	# ---------------------------------------------------------
2129	>	# Tests whether HEADER exists, giving a warning if it cannot be compiled using
2130	>	# the include files in INCLUDES and setting the cache variable VAR
2131	>	# accordingly.
2132	>	ac_fn_cxx_check_header_mongrel ()
2133	>	{
2134	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2135	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2136	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2137	>	$as_echo_n "checking for $2... " >&6; }
2138	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2139	>	$as_echo_n "(cached) " >&6
2140	>	fi
2141	>	eval ac_res=\$$3
2142	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2143	>	$as_echo "$ac_res" >&6; }
2144	>	else
2145	>	# Is the header compilable?
2146	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2147	>	$as_echo_n "checking $2 usability... " >&6; }
2148	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2149	>	/* end confdefs.h. */
2150	>	$4
2151	>	#include <$2>
2152	>	_ACEOF
2153	>	if ac_fn_cxx_try_compile "$LINENO"; then :
2154	>	ac_header_compiler=yes
2155	>	else
2156	>	ac_header_compiler=no
2157	>	fi
2158	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2159	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2160	>	$as_echo "$ac_header_compiler" >&6; }
2161	>
2162	>	# Is the header present?
2163	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2164	>	$as_echo_n "checking $2 presence... " >&6; }
2165	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2166	>	/* end confdefs.h. */
2167	>	#include <$2>
2168	>	_ACEOF
2169	>	if ac_fn_cxx_try_cpp "$LINENO"; then :
2170	>	ac_header_preproc=yes
2171	>	else
2172	>	ac_header_preproc=no
2173	>	fi
2174	>	rm -f conftest.err conftest.$ac_ext
2175	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2176	>	$as_echo "$ac_header_preproc" >&6; }
2177	>
2178	>	# So? What about this header?
2179	>	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2180	>	yes:no: )
2181	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2182	>	$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2183	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2184	>	$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2185	>	;;
2186	>	no:yes:* )
2187	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2188	>	$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2189	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
2190	>	$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
2191	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2192	>	$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2193	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
2194	>	$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
2195	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2196	>	$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2197	>	( cat <<\_ASBOX
2198	>	## ------------------------------ ##
2199	>	## Report this to gezelter@nd.edu ##
2200	>	## ------------------------------ ##
2201	>	_ASBOX
2202	>	) \| sed "s/^/$as_me: WARNING: /" >&2
2203	>	;;
2204	>	esac
2205	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2206	>	$as_echo_n "checking for $2... " >&6; }
2207	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2208	>	$as_echo_n "(cached) " >&6
2209	>	else
2210	>	eval "$3=\$ac_header_compiler"
2211	>	fi
2212	>	eval ac_res=\$$3
2213	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2214	>	$as_echo "$ac_res" >&6; }
2215	>	fi
2216	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2217	>
2218	>	} # ac_fn_cxx_check_header_mongrel
2219	>
2220	>	# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
2221	>	# -------------------------------------------
2222	>	# Tests whether TYPE exists after having included INCLUDES, setting cache
2223	>	# variable VAR accordingly.
2224	>	ac_fn_c_check_type ()
2225	>	{
2226	>	as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2227	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2228	>	$as_echo_n "checking for $2... " >&6; }
2229	>	if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2230	>	$as_echo_n "(cached) " >&6
2231	>	else
2232	>	eval "$3=no"
2233	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2234	>	/* end confdefs.h. */
2235	>	$4
2236	>	#ifdef FC_DUMMY_MAIN
2237	>	#ifndef FC_DUMMY_MAIN_EQ_F77
2238	>	# ifdef __cplusplus
2239	>	extern "C"
2240	>	# endif
2241	>	int FC_DUMMY_MAIN() { return 1; }
2242	>	#endif
2243	>	#endif
2244	>	int
2245	>	main ()
2246	>	{
2247	>	if (sizeof ($2))
2248	>	return 0;
2249	>	;
2250	>	return 0;
2251	>	}
2252	>	_ACEOF
2253	>	if ac_fn_c_try_compile "$LINENO"; then :
2254	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2255	>	/* end confdefs.h. */
2256	>	$4
2257	>	#ifdef FC_DUMMY_MAIN
2258	>	#ifndef FC_DUMMY_MAIN_EQ_F77
2259	>	# ifdef __cplusplus
2260	>	extern "C"
2261	>	# endif
2262	>	int FC_DUMMY_MAIN() { return 1; }
2263	>	#endif
2264	>	#endif
2265	>	int
2266	>	main ()
2267	>	{
2268	>	if (sizeof (($2)))
2269	>	return 0;
2270	>	;
2271	>	return 0;
2272	>	}
2273	>	_ACEOF
2274	>	if ac_fn_c_try_compile "$LINENO"; then :
2275	>
2276	>	else
2277	>	eval "$3=yes"
2278	>	fi
2279	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2280	>	fi
2281	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2282	>	fi
2283	>	eval ac_res=\$$3
2284	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2285	>	$as_echo "$ac_res" >&6; }
2286	>	eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2287	>
2288	>	} # ac_fn_c_check_type
2289	>	cat >config.log <<_ACEOF
2290	>	This file contains any messages produced by compilers while
2291	>	running configure, to aid debugging if configure makes a mistake.
2292	>
2293	>	It was created by OOPSE $as_me 4.0, which was
2294	>	generated by GNU Autoconf 2.64. Invocation command line was
2295	>
2296	>	$ $0 $@
2297	>
2298	>	_ACEOF
2299	>	exec 5>>config.log
2300	>	{
2301	>	cat <<_ASUNAME
2302	>	## --------- ##
2303	>	## Platform. ##
2304	>	## --------- ##
2305	>
2306	>	hostname = `(hostname \|\| uname -n) 2>/dev/null \| sed 1q`
2307	>	uname -m = `(uname -m) 2>/dev/null \|\| echo unknown`
2308	>	uname -r = `(uname -r) 2>/dev/null \|\| echo unknown`
2309	>	uname -s = `(uname -s) 2>/dev/null \|\| echo unknown`
2310	>	uname -v = `(uname -v) 2>/dev/null \|\| echo unknown`
2311	>
2312	>	/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null \|\| echo unknown`
2313	>	/bin/uname -X = `(/bin/uname -X) 2>/dev/null \|\| echo unknown`
2314	>
2315	>	/bin/arch = `(/bin/arch) 2>/dev/null \|\| echo unknown`
2316	>	/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null \|\| echo unknown`
2317	>	/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null \|\| echo unknown`
2318	>	/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null \|\| echo unknown`
2319	>	/bin/machine = `(/bin/machine) 2>/dev/null \|\| echo unknown`
2320	>	/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null \|\| echo unknown`
2321	>	/bin/universe = `(/bin/universe) 2>/dev/null \|\| echo unknown`
2322	>
2323	>	_ASUNAME
2324	>
2325	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2326	>	for as_dir in $PATH
2327	>	do
2328	>	IFS=$as_save_IFS
2329	>	test -z "$as_dir" && as_dir=.
2330	>	$as_echo "PATH: $as_dir"
2331	>	done
2332	>	IFS=$as_save_IFS
2333	>
2334	>	} >&5
2335	>
2336	>	cat >&5 <<_ACEOF
2337	>
2338	>
2339	>	## ----------- ##
2340	>	## Core tests. ##
2341	>	## ----------- ##
2342	>
2343	>	_ACEOF
2344	>
2345	>
2346	>	# Keep a trace of the command line.
2347		# Strip out --no-create and --no-recursion so they do not pile up.
2348		# Strip out --silent because we don't want to record it for future runs.
2349		# Also quote any args containing shell meta-characters.
#	Line 1632 \| Line 2365 \| do
2365		ac_arg=`$as_echo "$ac_arg" \| sed "s/'/'\\\\\\\\''/g"` ;;
2366		esac
2367		case $ac_pass in
2368	<	1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
2368	>	1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2369		2)
2370	<	ac_configure_args1="$ac_configure_args1 '$ac_arg'"
2370	>	as_fn_append ac_configure_args1 " '$ac_arg'"
2371		if test $ac_must_keep_next = true; then
2372		ac_must_keep_next=false # Got value, back to normal.
2373		else
#	Line 1650 \| Line 2383 \| do
2383		-* ) ac_must_keep_next=true ;;
2384		esac
2385		fi
2386	<	ac_configure_args="$ac_configure_args '$ac_arg'"
2386	>	as_fn_append ac_configure_args " '$ac_arg'"
2387		;;
2388		esac
2389		done
2390		done
2391	<	$as_unset ac_configure_args0 \|\| test "${ac_configure_args0+set}" != set \|\| { ac_configure_args0=; export ac_configure_args0; }
2392	<	$as_unset ac_configure_args1 \|\| test "${ac_configure_args1+set}" != set \|\| { ac_configure_args1=; export ac_configure_args1; }
2391	>	{ ac_configure_args0=; unset ac_configure_args0;}
2392	>	{ ac_configure_args1=; unset ac_configure_args1;}
2393
2394		# When interrupted or exit'd, cleanup temporary files, and complete
2395		# config.log. We remove comments because anyway the quotes in there
#	Line 1681 \| Line 2414 \| _ASBOX
2414		case $ac_val in #(
2415		${as_nl})
2416		case $ac_var in #(
2417	<	_cv_) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
2418	<	$as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
2417	>	_cv_) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2418	>	$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2419		esac
2420		case $ac_var in #(
2421		_ \| IFS \| as_nl) ;; #(
2422		BASH_ARGV \| BASH_SOURCE) eval $ac_var= ;; #(
2423	<	*) $as_unset $ac_var ;;
2423	>	*) { eval $ac_var=; unset $ac_var;} ;;
2424		esac ;;
2425		esac
2426		done
#	Line 1759 \| Line 2492 \| for ac_signal in 1 2 13 15; do
2492		exit $exit_status
2493		' 0
2494		for ac_signal in 1 2 13 15; do
2495	<	trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
2495	>	trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
2496		done
2497		ac_signal=0
2498
2499		# confdefs.h avoids OS command line length limits that DEFS can exceed.
2500		rm -f -r conftest* confdefs.h
2501
2502	+	$as_echo "/* confdefs.h */" > confdefs.h
2503	+
2504		# Predefined preprocessor variables.
2505
2506		cat >>confdefs.h <<_ACEOF
2507		#define PACKAGE_NAME "$PACKAGE_NAME"
2508		_ACEOF
2509
1775	–
2510		cat >>confdefs.h <<_ACEOF
2511		#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
2512		_ACEOF
2513
1780	–
2514		cat >>confdefs.h <<_ACEOF
2515		#define PACKAGE_VERSION "$PACKAGE_VERSION"
2516		_ACEOF
2517
1785	–
2518		cat >>confdefs.h <<_ACEOF
2519		#define PACKAGE_STRING "$PACKAGE_STRING"
2520		_ACEOF
2521
1790	–
2522		cat >>confdefs.h <<_ACEOF
2523		#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
2524		_ACEOF
2525
2526	+	cat >>confdefs.h <<_ACEOF
2527	+	#define PACKAGE_URL "$PACKAGE_URL"
2528	+	_ACEOF
2529
2530	+
2531		# Let the site file select an alternate cache file if it wants to.
2532		# Prefer an explicitly selected file to automatically selected ones.
2533		ac_site_file1=NONE
#	Line 1810 \| Line 2545 \| do
2545		do
2546		test "x$ac_site_file" = xNONE && continue
2547		if test -r "$ac_site_file"; then
2548	<	{ $as_echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
2548	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2549		$as_echo "$as_me: loading site script $ac_site_file" >&6;}
2550		sed 's/^/\| /' "$ac_site_file" >&5
2551		. "$ac_site_file"
#	Line 1821 \| Line 2556 \| if test -r "$cache_file"; then
2556		# Some versions of bash will fail to source /dev/null (special
2557		# files actually), so we avoid doing that.
2558		if test -f "$cache_file"; then
2559	<	{ $as_echo "$as_me:$LINENO: loading cache $cache_file" >&5
2559	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2560		$as_echo "$as_me: loading cache $cache_file" >&6;}
2561		case $cache_file in
2562		[\\/]* \| ?:[\\/]* ) . "$cache_file";;
#	Line 1829 \| Line 2564 \| else
2564		esac
2565		fi
2566		else
2567	<	{ $as_echo "$as_me:$LINENO: creating cache $cache_file" >&5
2567	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
2568		$as_echo "$as_me: creating cache $cache_file" >&6;}
2569		>$cache_file
2570		fi
#	Line 1844 \| Line 2579 \| for ac_var in $ac_precious_vars; do
2579		eval ac_new_val=\$ac_env_${ac_var}_value
2580		case $ac_old_set,$ac_new_set in
2581		set,)
2582	<	{ $as_echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2582	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2583		$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2584		ac_cache_corrupted=: ;;
2585		,set)
2586	<	{ $as_echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
2586	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
2587		$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2588		ac_cache_corrupted=: ;;
2589		,);;
#	Line 1858 \| Line 2593 \| $as_echo "$as_me: error: \`$ac_var' was not set in the
2593		ac_old_val_w=`echo x $ac_old_val`
2594		ac_new_val_w=`echo x $ac_new_val`
2595		if test "$ac_old_val_w" != "$ac_new_val_w"; then
2596	<	{ $as_echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
2596	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
2597		$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2598		ac_cache_corrupted=:
2599		else
2600	<	{ $as_echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2600	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2601		$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
2602		eval $ac_var=\$ac_old_val
2603		fi
2604	<	{ $as_echo "$as_me:$LINENO: former value: \`$ac_old_val'" >&5
2604	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
2605		$as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
2606	<	{ $as_echo "$as_me:$LINENO: current value: \`$ac_new_val'" >&5
2606	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
2607		$as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
2608		fi;;
2609		esac
#	Line 1880 \| Line 2615 \| $as_echo "$as_me: current value: \`$ac_new_val'" >&2
2615		esac
2616		case " $ac_configure_args " in
2617		" '$ac_arg' ") ;; # Avoid dups. Use of quotes ensures accuracy.
2618	<	*) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
2618	>	*) as_fn_append ac_configure_args " '$ac_arg'" ;;
2619		esac
2620		fi
2621		done
2622		if $ac_cache_corrupted; then
2623	<	{ $as_echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
2623	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2624	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2625	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
2626		$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2627	<	{ { $as_echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1891	<	$as_echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1892	<	{ (exit 1); exit 1; }; }
2627	>	as_fn_error "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
2628		fi
2629	+	## -------------------- ##
2630	+	## Main body of script. ##
2631	+	## -------------------- ##
2632
1895	–
1896	–
1897	–
1898	–
1899	–
1900	–
1901	–
1902	–
1903	–
1904	–
1905	–
1906	–
1907	–
1908	–
1909	–
1910	–
1911	–
1912	–
1913	–
1914	–
1915	–
1916	–
1917	–
1918	–
2633		ac_ext=c
2634		ac_cpp='$CPP $CPPFLAGS'
2635		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 1925 \| Line 2639 \| for ac_dir in ac-tools "$srcdir"/ac-tools; do
2639
2640		ac_aux_dir=
2641		for ac_dir in ac-tools "$srcdir"/ac-tools; do
2642	<	if test -f "$ac_dir/install-sh"; then
2643	<	ac_aux_dir=$ac_dir
2644	<	ac_install_sh="$ac_aux_dir/install-sh -c"
2645	<	break
2646	<	elif test -f "$ac_dir/install.sh"; then
2647	<	ac_aux_dir=$ac_dir
2648	<	ac_install_sh="$ac_aux_dir/install.sh -c"
1935	<	break
1936	<	elif test -f "$ac_dir/shtool"; then
1937	<	ac_aux_dir=$ac_dir
1938	<	ac_install_sh="$ac_aux_dir/shtool install -c"
1939	<	break
1940	<	fi
2642	>	for ac_t in install-sh install.sh shtool; do
2643	>	if test -f "$ac_dir/$ac_t"; then
2644	>	ac_aux_dir=$ac_dir
2645	>	ac_install_sh="$ac_aux_dir/$ac_t -c"
2646	>	break 2
2647	>	fi
2648	>	done
2649		done
2650		if test -z "$ac_aux_dir"; then
2651	<	{ { $as_echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&5
1944	<	$as_echo "$as_me: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&2;}
1945	<	{ (exit 1); exit 1; }; }
2651	>	as_fn_error "cannot find install-sh, install.sh, or shtool in ac-tools \"$srcdir\"/ac-tools" "$LINENO" 5
2652		fi
2653
2654		# These three variables are undocumented and unsupported,
#	Line 2106 \| Line 2812 \| ac_config_headers="$ac_config_headers src/config.h"
2812
2813
2814
2815	<	# ACX_MPI_GET_PROG
2816	<
2817	<	# ACX_DETECT_MPI_IMPLEMENTATION
2818	<
2819	<
2815	>	# ===========================================================================
2816	>	# http://www.nongnu.org/autoconf-archive/ax_mpi.html
2817	>	# ===========================================================================
2818	>	#
2819	>	# SYNOPSIS
2820	>	#
2821	>	# AX_MPI([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
2822	>	#
2823	>	# DESCRIPTION
2824	>	#
2825	>	# This macro tries to find out how to compile programs that use MPI
2826	>	# (Message Passing Interface), a standard API for parallel process
2827	>	# communication (see http://www-unix.mcs.anl.gov/mpi/)
2828	>	#
2829	>	# On success, it sets the MPICC, MPICXX, MPIF77, or MPIFC output variable
2830	>	# to the name of the MPI compiler, depending upon the current language.
2831	>	# (This may just be $CC/$CXX/$F77/$FC, but is more often something like
2832	>	# mpicc/mpiCC/mpif77/mpif90.) It also sets MPILIBS to any libraries that
2833	>	# are needed for linking MPI (e.g. -lmpi or -lfmpi, if a special
2834	>	# MPICC/MPICXX/MPIF77/MPIFC was not found).
2835	>	#
2836	>	# If you want to compile everything with MPI, you should set:
2837	>	#
2838	>	# CC="MPICC" #OR# CXX="MPICXX" #OR# F77="MPIF77" #OR# FC="MPIFC"
2839	>	# LIBS="$MPILIBS $LIBS"
2840	>	#
2841	>	# NOTE: The above assumes that you will use $CC (or whatever) for linking
2842	>	# as well as for compiling. (This is the default for automake and most
2843	>	# Makefiles.)
2844	>	#
2845	>	# The user can force a particular library/compiler by setting the
2846	>	# MPICC/MPICXX/MPIF77/MPIFC and/or MPILIBS environment variables.
2847	>	#
2848	>	# ACTION-IF-FOUND is a list of shell commands to run if an MPI library is
2849	>	# found, and ACTION-IF-NOT-FOUND is a list of commands to run if it is not
2850	>	# found. If ACTION-IF-FOUND is not specified, the default action will
2851	>	# define HAVE_MPI.
2852	>	#
2853	>	# LICENSE
2854	>	#
2855	>	# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
2856	>	# Copyright (c) 2008 Julian C. Cummings <cummings@cacr.caltech.edu>
2857	>	#
2858	>	# This program is free software: you can redistribute it and/or modify it
2859	>	# under the terms of the GNU General Public License as published by the
2860	>	# Free Software Foundation, either version 3 of the License, or (at your
2861	>	# option) any later version.
2862	>	#
2863	>	# This program is distributed in the hope that it will be useful, but
2864	>	# WITHOUT ANY WARRANTY; without even the implied warranty of
2865	>	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
2866	>	# Public License for more details.
2867	>	#
2868	>	# You should have received a copy of the GNU General Public License along
2869	>	# with this program. If not, see <http://www.gnu.org/licenses/>.
2870	>	#
2871	>	# As a special exception, the respective Autoconf Macro's copyright owner
2872	>	# gives unlimited permission to copy, distribute and modify the configure
2873	>	# scripts that are the output of Autoconf when processing the Macro. You
2874	>	# need not follow the terms of the GNU General Public License when using
2875	>	# or distributing such scripts, even though portions of the text of the
2876	>	# Macro appear in them. The GNU General Public License (GPL) does govern
2877	>	# all other use of the material that constitutes the Autoconf Macro.
2878	>	#
2879	>	# This special exception to the GPL applies to versions of the Autoconf
2880	>	# Macro released by the Autoconf Archive. When you make and distribute a
2881	>	# modified version of the Autoconf Macro, you may extend this special
2882	>	# exception to the GPL to apply to your modified version as well.
2883
2884	+	# This is what autoupdate's m4 run will expand. It fires
2885	+	# the warning (with _au_warn_XXX), outputs it into the
2886	+	# updated configure.ac (with AC_DIAGNOSE), and then outputs
2887	+	# the replacement expansion.
2888
2889
2890	<	# ACX_MPI
2890	>	# This is an auxiliary macro that is also run when
2891	>	# autoupdate runs m4. It simply calls m4_warning, but
2892	>	# we need a wrapper so that each warning is emitted only
2893	>	# once. We break the quoting in m4_warning's argument in
2894	>	# order to expand this macro's arguments, not AU_DEFUN's.
2895
2896
2897	+	# Finally, this is the expansion that is picked up by
2898	+	# autoconf. It tells the user to run autoupdate, and
2899	+	# then outputs the replacement expansion. We do not care
2900	+	# about autoupdate's warning because that contains
2901	+	# information on what to do after running autoupdate.
2902
2903
2904
#	Line 2141 \| Line 2923 \| ac_config_headers="$ac_config_headers src/config.h"
2923
2924
2925
2144	–
2926		# This is taken from http://autoqt.sourceforge.net/
2927		# Copyright (c) 2002, Geoffrey Wossum
2928		# All rights reserved.
#	Line 2182 \| Line 2963 \| $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 \|
2963		# who am i
2964		# Make sure we can run config.sub.
2965		$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 \|\|
2966	<	{ { $as_echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
2186	<	$as_echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
2187	<	{ (exit 1); exit 1; }; }
2966	>	as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
2967
2968	<	{ $as_echo "$as_me:$LINENO: checking build system type" >&5
2968	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
2969		$as_echo_n "checking build system type... " >&6; }
2970	<	if test "${ac_cv_build+set}" = set; then
2970	>	if test "${ac_cv_build+set}" = set; then :
2971		$as_echo_n "(cached) " >&6
2972		else
2973		ac_build_alias=$build_alias
2974		test "x$ac_build_alias" = x &&
2975		ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
2976		test "x$ac_build_alias" = x &&
2977	<	{ { $as_echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
2199	<	$as_echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
2200	<	{ (exit 1); exit 1; }; }
2977	>	as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
2978		ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` \|\|
2979	<	{ { $as_echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
2203	<	$as_echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
2204	<	{ (exit 1); exit 1; }; }
2979	>	as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
2980
2981		fi
2982	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_build" >&5
2982	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
2983		$as_echo "$ac_cv_build" >&6; }
2984		case $ac_cv_build in
2985		--*) ;;
2986	<	*) { { $as_echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
2212	<	$as_echo "$as_me: error: invalid value of canonical build" >&2;}
2213	<	{ (exit 1); exit 1; }; };;
2986	>	*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
2987		esac
2988		build=$ac_cv_build
2989		ac_save_IFS=$IFS; IFS='-'
#	Line 2226 \| Line 2999 \| *case $build_os in \ ) build_os=`echo "$build_os" \| s*
2999		case $build_os in \ ) build_os=`echo "$build_os" \| sed 's/ /-/g'`;; esac
3000
3001
3002	<	{ $as_echo "$as_me:$LINENO: checking host system type" >&5
3002	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
3003		$as_echo_n "checking host system type... " >&6; }
3004	<	if test "${ac_cv_host+set}" = set; then
3004	>	if test "${ac_cv_host+set}" = set; then :
3005		$as_echo_n "(cached) " >&6
3006		else
3007		if test "x$host_alias" = x; then
3008		ac_cv_host=$ac_cv_build
3009		else
3010		ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` \|\|
3011	<	{ { $as_echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
2239	<	$as_echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
2240	<	{ (exit 1); exit 1; }; }
3011	>	as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
3012		fi
3013
3014		fi
3015	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_host" >&5
3015	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
3016		$as_echo "$ac_cv_host" >&6; }
3017		case $ac_cv_host in
3018		--*) ;;
3019	<	*) { { $as_echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
2249	<	$as_echo "$as_me: error: invalid value of canonical host" >&2;}
2250	<	{ (exit 1); exit 1; }; };;
3019	>	*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
3020		esac
3021		host=$ac_cv_host
3022		ac_save_IFS=$IFS; IFS='-'
#	Line 2283 \| Line 3052 \| fi
3052		OOPSE_HOME=${prefix}/oopse
3053		fi
3054		# Check whether --enable-oopse-home was given.
3055	<	if test "${enable_oopse_home+set}" = set; then
3055	>	if test "${enable_oopse_home+set}" = set; then :
3056		enableval=$enable_oopse_home; OOPSE_HOME="${enableval}"
3057		fi
3058
#	Line 2293 \| Line 3062 \| debug=0
3062
3063		debug=0
3064		# Check whether --enable-debug was given.
3065	<	if test "${enable_debug+set}" = set; then
3065	>	if test "${enable_debug+set}" = set; then :
3066		enableval=$enable_debug; debug=1
3067		fi
3068
3069		if test "${DEBUG}"; then
3070
3071	<	cat >>confdefs.h <<\_ACEOF
2303	<	#define debug 1
2304	<	_ACEOF
3071	>	$as_echo "#define debug 1" >>confdefs.h
3072
3073		msg="$msg, debug mode"
3074		fi
3075
3076
3077		# Check whether --enable-single was given.
3078	<	if test "${enable_single+set}" = set; then
3078	>	if test "${enable_single+set}" = set; then :
3079		enableval=$enable_single; ok=$enableval
3080		else
3081		ok=no
3082		fi
3083
3084		# Check whether --enable-float was given.
3085	<	if test "${enable_float+set}" = set; then
3085	>	if test "${enable_float+set}" = set; then :
3086		enableval=$enable_float; ok=$enableval
3087		fi
3088
3089		if test "$ok" = "yes"; then
3090
3091	<	cat >>confdefs.h <<\_ACEOF
2325	<	#define SINGLE_PRECISION 1
2326	<	_ACEOF
3091	>	$as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3092
3093		USE_SINGLE_PRECISION=yes
3094
#	Line 2334 \| Line 3099 \| set dummy $ac_prog; ac_word=$2
3099		do
3100		# Extract the first word of "$ac_prog", so it can be a program name with args.
3101		set dummy $ac_prog; ac_word=$2
3102	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3102	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3103		$as_echo_n "checking for $ac_word... " >&6; }
3104	<	if test "${ac_cv_prog_ac_cc_set+set}" = set; then
3104	>	if test "${ac_cv_prog_ac_cc_set+set}" = set; then :
3105		$as_echo_n "(cached) " >&6
3106		else
3107		if test -n "$ac_cc_set"; then
#	Line 2347 \| Line 3112 \| do
3112		do
3113		IFS=$as_save_IFS
3114		test -z "$as_dir" && as_dir=.
3115	<	for ac_exec_ext in '' $ac_executable_extensions; do
3115	>	for ac_exec_ext in '' $ac_executable_extensions; do
3116		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3117		ac_cv_prog_ac_cc_set="$ac_prog"
3118	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3118	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3119		break 2
3120		fi
3121		done
3122	<	done
3122	>	done
3123		IFS=$as_save_IFS
3124
3125		fi
3126		fi
3127		ac_cc_set=$ac_cv_prog_ac_cc_set
3128		if test -n "$ac_cc_set"; then
3129	<	{ $as_echo "$as_me:$LINENO: result: $ac_cc_set" >&5
3129	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_set" >&5
3130		$as_echo "$ac_cc_set" >&6; }
3131		else
3132	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3132	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3133		$as_echo "no" >&6; }
3134		fi
3135
#	Line 2373 \| Line 3138 \| test -n "$ac_cc_set" \|\| ac_cc_set="no"
3138		done
3139		test -n "$ac_cc_set" \|\| ac_cc_set="no"
3140
3141	<	if test $ac_cc_set != no; then
3141	>	if test $ac_cc_set != no; then :
3142
3143		# Extract the first word of "$ac_cc_set", so it can be a program name with args.
3144		set dummy $ac_cc_set; ac_word=$2
3145	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3145	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3146		$as_echo_n "checking for $ac_word... " >&6; }
3147	<	if test "${ac_cv_path_ac_cc_path+set}" = set; then
3147	>	if test "${ac_cv_path_ac_cc_path+set}" = set; then :
3148		$as_echo_n "(cached) " >&6
3149		else
3150		case $ac_cc_path in
#	Line 2392 \| Line 3157 \| do
3157		do
3158		IFS=$as_save_IFS
3159		test -z "$as_dir" && as_dir=.
3160	<	for ac_exec_ext in '' $ac_executable_extensions; do
3160	>	for ac_exec_ext in '' $ac_executable_extensions; do
3161		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3162		ac_cv_path_ac_cc_path="$as_dir/$ac_word$ac_exec_ext"
3163	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3163	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3164		break 2
3165		fi
3166		done
3167	<	done
3167	>	done
3168		IFS=$as_save_IFS
3169
3170		test -z "$ac_cv_path_ac_cc_path" && ac_cv_path_ac_cc_path="no"
#	Line 2408 \| Line 3173 \| if test -n "$ac_cc_path"; then
3173		fi
3174		ac_cc_path=$ac_cv_path_ac_cc_path
3175		if test -n "$ac_cc_path"; then
3176	<	{ $as_echo "$as_me:$LINENO: result: $ac_cc_path" >&5
3176	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_path" >&5
3177		$as_echo "$ac_cc_path" >&6; }
3178		else
3179	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3179	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3180		$as_echo "no" >&6; }
3181		fi
3182
3183
3184		else
3185
3186	<	{ { $as_echo "$as_me:$LINENO: error: Specified C compiler $CC doesn't seem to exist!" >&5
2422	<	$as_echo "$as_me: error: Specified C compiler $CC doesn't seem to exist!" >&2;}
2423	<	{ (exit 1); exit 1; }; }
3186	>	as_fn_error "Specified C compiler $CC doesn't seem to exist!" "$LINENO" 5
3187		fi
3188
3189	+	if test $ac_cc_path != no; then :
3190
3191	<	if test $ac_cc_path != no; then
2428	<
2429	<	{ $as_echo "$as_me:$LINENO: Will attempt to use $CC as C compiler" >&5
3191	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CC as C compiler" >&5
3192		$as_echo "$as_me: Will attempt to use $CC as C compiler" >&6;}
3193	+	MPICC=$CC
3194	+
3195		else
3196
3197	<	{ { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified C compiler $CC" >&5
2434	<	$as_echo "$as_me: error: Can't find path to user-specified C compiler $CC" >&2;}
2435	<	{ (exit 1); exit 1; }; }
3197	>	as_fn_error "Can't find path to user-specified C compiler $CC" "$LINENO" 5
3198		fi
2437	–
3199		fi
3200
3201		if test x"$CXX" != x; then
#	Line 2442 \| Line 3203 \| set dummy $ac_prog; ac_word=$2
3203		do
3204		# Extract the first word of "$ac_prog", so it can be a program name with args.
3205		set dummy $ac_prog; ac_word=$2
3206	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3206	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3207		$as_echo_n "checking for $ac_word... " >&6; }
3208	<	if test "${ac_cv_prog_ac_cxx_set+set}" = set; then
3208	>	if test "${ac_cv_prog_ac_cxx_set+set}" = set; then :
3209		$as_echo_n "(cached) " >&6
3210		else
3211		if test -n "$ac_cxx_set"; then
#	Line 2455 \| Line 3216 \| do
3216		do
3217		IFS=$as_save_IFS
3218		test -z "$as_dir" && as_dir=.
3219	<	for ac_exec_ext in '' $ac_executable_extensions; do
3219	>	for ac_exec_ext in '' $ac_executable_extensions; do
3220		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3221		ac_cv_prog_ac_cxx_set="$ac_prog"
3222	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3222	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3223		break 2
3224		fi
3225		done
3226	<	done
3226	>	done
3227		IFS=$as_save_IFS
3228
3229		fi
3230		fi
3231		ac_cxx_set=$ac_cv_prog_ac_cxx_set
3232		if test -n "$ac_cxx_set"; then
3233	<	{ $as_echo "$as_me:$LINENO: result: $ac_cxx_set" >&5
3233	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_set" >&5
3234		$as_echo "$ac_cxx_set" >&6; }
3235		else
3236	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3236	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3237		$as_echo "no" >&6; }
3238		fi
3239
#	Line 2481 \| Line 3242 \| test -n "$ac_cxx_set" \|\| ac_cxx_set="no"
3242		done
3243		test -n "$ac_cxx_set" \|\| ac_cxx_set="no"
3244
3245	<	if test $ac_cxx_set != no; then
3245	>	if test $ac_cxx_set != no; then :
3246
3247		# Extract the first word of "$ac_cxx_set", so it can be a program name with args.
3248		set dummy $ac_cxx_set; ac_word=$2
3249	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3249	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3250		$as_echo_n "checking for $ac_word... " >&6; }
3251	<	if test "${ac_cv_path_ac_cxx_path+set}" = set; then
3251	>	if test "${ac_cv_path_ac_cxx_path+set}" = set; then :
3252		$as_echo_n "(cached) " >&6
3253		else
3254		case $ac_cxx_path in
#	Line 2500 \| Line 3261 \| do
3261		do
3262		IFS=$as_save_IFS
3263		test -z "$as_dir" && as_dir=.
3264	<	for ac_exec_ext in '' $ac_executable_extensions; do
3264	>	for ac_exec_ext in '' $ac_executable_extensions; do
3265		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3266		ac_cv_path_ac_cxx_path="$as_dir/$ac_word$ac_exec_ext"
3267	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3267	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3268		break 2
3269		fi
3270		done
3271	<	done
3271	>	done
3272		IFS=$as_save_IFS
3273
3274		test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
#	Line 2516 \| Line 3277 \| if test -n "$ac_cxx_path"; then
3277		fi
3278		ac_cxx_path=$ac_cv_path_ac_cxx_path
3279		if test -n "$ac_cxx_path"; then
3280	<	{ $as_echo "$as_me:$LINENO: result: $ac_cxx_path" >&5
3280	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_path" >&5
3281		$as_echo "$ac_cxx_path" >&6; }
3282		else
3283	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3283	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3284		$as_echo "no" >&6; }
3285		fi
3286
3287
3288		else
3289
3290	<	{ { $as_echo "$as_me:$LINENO: error: Specified C++ compiler $CXX doesn't seem to exist!" >&5
2530	<	$as_echo "$as_me: error: Specified C++ compiler $CXX doesn't seem to exist!" >&2;}
2531	<	{ (exit 1); exit 1; }; }
3290	>	as_fn_error "Specified C++ compiler $CXX doesn't seem to exist!" "$LINENO" 5
3291		fi
3292
3293	+	if test $ac_cxx_path != no; then :
3294
3295	<	if test $ac_cxx_path != no; then
2536	<
2537	<	{ $as_echo "$as_me:$LINENO: Will attempt to use $CXX as C++ compiler" >&5
3295	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CXX as C++ compiler" >&5
3296		$as_echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3297	+	MPICXX=$CXX
3298	+
3299		else
3300
3301	<	{ { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified C++ compiler $CXX" >&5
2542	<	$as_echo "$as_me: error: Can't find path to user-specified C++ compiler $CXX" >&2;}
2543	<	{ (exit 1); exit 1; }; }
3301	>	as_fn_error "Can't find path to user-specified C++ compiler $CXX" "$LINENO" 5
3302		fi
2545	–
3303		fi
3304
3305		if test x"$FC" != x; then
#	Line 2550 \| Line 3307 \| set dummy $ac_prog; ac_word=$2
3307		do
3308		# Extract the first word of "$ac_prog", so it can be a program name with args.
3309		set dummy $ac_prog; ac_word=$2
3310	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3310	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3311		$as_echo_n "checking for $ac_word... " >&6; }
3312	<	if test "${ac_cv_prog_ac_fc_set+set}" = set; then
3312	>	if test "${ac_cv_prog_ac_fc_set+set}" = set; then :
3313		$as_echo_n "(cached) " >&6
3314		else
3315		if test -n "$ac_fc_set"; then
#	Line 2563 \| Line 3320 \| do
3320		do
3321		IFS=$as_save_IFS
3322		test -z "$as_dir" && as_dir=.
3323	<	for ac_exec_ext in '' $ac_executable_extensions; do
3323	>	for ac_exec_ext in '' $ac_executable_extensions; do
3324		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3325		ac_cv_prog_ac_fc_set="$ac_prog"
3326	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3326	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3327		break 2
3328		fi
2572	–	done
3329		done
3330	+	done
3331		IFS=$as_save_IFS
3332
3333		fi
3334		fi
3335		ac_fc_set=$ac_cv_prog_ac_fc_set
3336		if test -n "$ac_fc_set"; then
3337	<	{ $as_echo "$as_me:$LINENO: result: $ac_fc_set" >&5
3337	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_set" >&5
3338		$as_echo "$ac_fc_set" >&6; }
3339		else
3340	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3340	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3341		$as_echo "no" >&6; }
3342		fi
3343
#	Line 2589 \| Line 3346 \| test -n "$ac_fc_set" \|\| ac_fc_set="no"
3346		done
3347		test -n "$ac_fc_set" \|\| ac_fc_set="no"
3348
3349	<	if test $ac_fc_set != no; then
3349	>	if test $ac_fc_set != no; then :
3350
3351		# Extract the first word of "$ac_fc_set", so it can be a program name with args.
3352		set dummy $ac_fc_set; ac_word=$2
3353	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3353	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3354		$as_echo_n "checking for $ac_word... " >&6; }
3355	<	if test "${ac_cv_path_ac_fc_path+set}" = set; then
3355	>	if test "${ac_cv_path_ac_fc_path+set}" = set; then :
3356		$as_echo_n "(cached) " >&6
3357		else
3358		case $ac_fc_path in
#	Line 2608 \| Line 3365 \| do
3365		do
3366		IFS=$as_save_IFS
3367		test -z "$as_dir" && as_dir=.
3368	<	for ac_exec_ext in '' $ac_executable_extensions; do
3368	>	for ac_exec_ext in '' $ac_executable_extensions; do
3369		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3370		ac_cv_path_ac_fc_path="$as_dir/$ac_word$ac_exec_ext"
3371	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3371	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3372		break 2
3373		fi
3374		done
3375	<	done
3375	>	done
3376		IFS=$as_save_IFS
3377
3378		test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
#	Line 2624 \| Line 3381 \| if test -n "$ac_fc_path"; then
3381		fi
3382		ac_fc_path=$ac_cv_path_ac_fc_path
3383		if test -n "$ac_fc_path"; then
3384	<	{ $as_echo "$as_me:$LINENO: result: $ac_fc_path" >&5
3384	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_path" >&5
3385		$as_echo "$ac_fc_path" >&6; }
3386		else
3387	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3387	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3388		$as_echo "no" >&6; }
3389		fi
3390
3391
3392		else
3393
3394	<	{ { $as_echo "$as_me:$LINENO: error: Specified Fortran compiler $FC doesn't seem to exist!" >&5
2638	<	$as_echo "$as_me: error: Specified Fortran compiler $FC doesn't seem to exist!" >&2;}
2639	<	{ (exit 1); exit 1; }; }
3394	>	as_fn_error "Specified Fortran compiler $FC doesn't seem to exist!" "$LINENO" 5
3395		fi
3396
3397	+	if test $ac_fc_path != no; then :
3398
3399	<	if test $ac_fc_path != no; then
2644	<
2645	<	{ $as_echo "$as_me:$LINENO: Will attempt to use $FC as Fortran compiler" >&5
3399	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $FC as Fortran compiler" >&5
3400		$as_echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3401	<	else
3401	>	MPIFC=$FC
3402
2649	–	{ { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified Fortran compiler $FC" >&5
2650	–	$as_echo "$as_me: error: Can't find path to user-specified Fortran compiler $FC" >&2;}
2651	–	{ (exit 1); exit 1; }; }
2652	–	fi
2653	–
2654	–	fi
2655	–
2656	–
2657	–
2658	–
2659	–	# Check whether --with-mpi was given.
2660	–	if test "${with_mpi+set}" = set; then
2661	–	withval=$with_mpi;
3403		else
2663	–	with_mpi="auto"
2664	–	fi
3404
3405	<	if test "x$with_mpi" != "xno"; then
2667	<
2668	<
2669	<	for ac_prog in $CC openmpicc mpicc
2670	<	do
2671	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
2672	<	set dummy $ac_prog; ac_word=$2
2673	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2674	<	$as_echo_n "checking for $ac_word... " >&6; }
2675	<	if test "${ac_cv_prog_acx_mpi_mpicc+set}" = set; then
2676	<	$as_echo_n "(cached) " >&6
2677	<	else
2678	<	if test -n "$acx_mpi_mpicc"; then
2679	<	ac_cv_prog_acx_mpi_mpicc="$acx_mpi_mpicc" # Let the user override the test.
2680	<	else
2681	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2682	<	for as_dir in $PATH
2683	<	do
2684	<	IFS=$as_save_IFS
2685	<	test -z "$as_dir" && as_dir=.
2686	<	for ac_exec_ext in '' $ac_executable_extensions; do
2687	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2688	<	ac_cv_prog_acx_mpi_mpicc="$ac_prog"
2689	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2690	<	break 2
2691	<	fi
2692	<	done
2693	<	done
2694	<	IFS=$as_save_IFS
2695	<
2696	<	fi
2697	<	fi
2698	<	acx_mpi_mpicc=$ac_cv_prog_acx_mpi_mpicc
2699	<	if test -n "$acx_mpi_mpicc"; then
2700	<	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicc" >&5
2701	<	$as_echo "$acx_mpi_mpicc" >&6; }
2702	<	else
2703	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
2704	<	$as_echo "no" >&6; }
2705	<	fi
2706	<
2707	<
2708	<	test -n "$acx_mpi_mpicc" && break
2709	<	done
2710	<	test -n "$acx_mpi_mpicc" \|\| acx_mpi_mpicc="no"
2711	<
2712	<	if test $acx_mpi_mpicc != no; then
2713	<
2714	<	# Extract the first word of "$acx_mpi_mpicc", so it can be a program name with args.
2715	<	set dummy $acx_mpi_mpicc; ac_word=$2
2716	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2717	<	$as_echo_n "checking for $ac_word... " >&6; }
2718	<	if test "${ac_cv_path_acx_mpi_mpicc_path+set}" = set; then
2719	<	$as_echo_n "(cached) " >&6
2720	<	else
2721	<	case $acx_mpi_mpicc_path in
2722	<	[\\/]* \| ?:[\\/]*)
2723	<	ac_cv_path_acx_mpi_mpicc_path="$acx_mpi_mpicc_path" # Let the user override the test with a path.
2724	<	;;
2725	<	*)
2726	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2727	<	for as_dir in $PATH
2728	<	do
2729	<	IFS=$as_save_IFS
2730	<	test -z "$as_dir" && as_dir=.
2731	<	for ac_exec_ext in '' $ac_executable_extensions; do
2732	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2733	<	ac_cv_path_acx_mpi_mpicc_path="$as_dir/$ac_word$ac_exec_ext"
2734	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2735	<	break 2
2736	<	fi
2737	<	done
2738	<	done
2739	<	IFS=$as_save_IFS
2740	<
2741	<	test -z "$ac_cv_path_acx_mpi_mpicc_path" && ac_cv_path_acx_mpi_mpicc_path="no"
2742	<	;;
2743	<	esac
2744	<	fi
2745	<	acx_mpi_mpicc_path=$ac_cv_path_acx_mpi_mpicc_path
2746	<	if test -n "$acx_mpi_mpicc_path"; then
2747	<	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicc_path" >&5
2748	<	$as_echo "$acx_mpi_mpicc_path" >&6; }
2749	<	else
2750	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
2751	<	$as_echo "no" >&6; }
3405	>	as_fn_error "Can't find path to user-specified Fortran compiler $FC" "$LINENO" 5
3406		fi
2753	–
2754	–
3407		fi
3408
2757	–	for ac_prog in $FC openmpif90 mpif90
2758	–	do
2759	–	# Extract the first word of "$ac_prog", so it can be a program name with args.
2760	–	set dummy $ac_prog; ac_word=$2
2761	–	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2762	–	$as_echo_n "checking for $ac_word... " >&6; }
2763	–	if test "${ac_cv_prog_acx_mpi_mpif90+set}" = set; then
2764	–	$as_echo_n "(cached) " >&6
2765	–	else
2766	–	if test -n "$acx_mpi_mpif90"; then
2767	–	ac_cv_prog_acx_mpi_mpif90="$acx_mpi_mpif90" # Let the user override the test.
2768	–	else
2769	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2770	–	for as_dir in $PATH
2771	–	do
2772	–	IFS=$as_save_IFS
2773	–	test -z "$as_dir" && as_dir=.
2774	–	for ac_exec_ext in '' $ac_executable_extensions; do
2775	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2776	–	ac_cv_prog_acx_mpi_mpif90="$ac_prog"
2777	–	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2778	–	break 2
2779	–	fi
2780	–	done
2781	–	done
2782	–	IFS=$as_save_IFS
3409
3410	<	fi
2785	<	fi
2786	<	acx_mpi_mpif90=$ac_cv_prog_acx_mpi_mpif90
2787	<	if test -n "$acx_mpi_mpif90"; then
2788	<	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_mpif90" >&5
2789	<	$as_echo "$acx_mpi_mpif90" >&6; }
2790	<	else
2791	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
2792	<	$as_echo "no" >&6; }
2793	<	fi
2794	<
2795	<
2796	<	test -n "$acx_mpi_mpif90" && break
2797	<	done
2798	<	test -n "$acx_mpi_mpif90" \|\| acx_mpi_mpif90="no"
2799	<
2800	<	if test $acx_mpi_mpif90 != no; then
2801	<
2802	<	# Extract the first word of "$acx_mpi_mpif90", so it can be a program name with args.
2803	<	set dummy $acx_mpi_mpif90; ac_word=$2
2804	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2805	<	$as_echo_n "checking for $ac_word... " >&6; }
2806	<	if test "${ac_cv_path_acx_mpi_mpif90_path+set}" = set; then
2807	<	$as_echo_n "(cached) " >&6
2808	<	else
2809	<	case $acx_mpi_mpif90_path in
2810	<	[\\/]* \| ?:[\\/]*)
2811	<	ac_cv_path_acx_mpi_mpif90_path="$acx_mpi_mpif90_path" # Let the user override the test with a path.
2812	<	;;
2813	<	*)
2814	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2815	<	for as_dir in $PATH
2816	<	do
2817	<	IFS=$as_save_IFS
2818	<	test -z "$as_dir" && as_dir=.
2819	<	for ac_exec_ext in '' $ac_executable_extensions; do
2820	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2821	<	ac_cv_path_acx_mpi_mpif90_path="$as_dir/$ac_word$ac_exec_ext"
2822	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2823	<	break 2
2824	<	fi
2825	<	done
2826	<	done
2827	<	IFS=$as_save_IFS
2828	<
2829	<	test -z "$ac_cv_path_acx_mpi_mpif90_path" && ac_cv_path_acx_mpi_mpif90_path="no"
2830	<	;;
2831	<	esac
2832	<	fi
2833	<	acx_mpi_mpif90_path=$ac_cv_path_acx_mpi_mpif90_path
2834	<	if test -n "$acx_mpi_mpif90_path"; then
2835	<	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_mpif90_path" >&5
2836	<	$as_echo "$acx_mpi_mpif90_path" >&6; }
2837	<	else
2838	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
2839	<	$as_echo "no" >&6; }
2840	<	fi
2841	<
2842	<
2843	<	fi
2844	<
2845	<	for ac_prog in $CXX openmpicxx openmpiCC openmpic++ mpicxx mpiCC mpic++
2846	<	do
2847	<	# Extract the first word of "$ac_prog", so it can be a program name with args.
2848	<	set dummy $ac_prog; ac_word=$2
2849	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2850	<	$as_echo_n "checking for $ac_word... " >&6; }
2851	<	if test "${ac_cv_prog_acx_mpi_mpicxx+set}" = set; then
2852	<	$as_echo_n "(cached) " >&6
2853	<	else
2854	<	if test -n "$acx_mpi_mpicxx"; then
2855	<	ac_cv_prog_acx_mpi_mpicxx="$acx_mpi_mpicxx" # Let the user override the test.
2856	<	else
2857	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2858	<	for as_dir in $PATH
2859	<	do
2860	<	IFS=$as_save_IFS
2861	<	test -z "$as_dir" && as_dir=.
2862	<	for ac_exec_ext in '' $ac_executable_extensions; do
2863	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2864	<	ac_cv_prog_acx_mpi_mpicxx="$ac_prog"
2865	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2866	<	break 2
2867	<	fi
2868	<	done
2869	<	done
2870	<	IFS=$as_save_IFS
2871	<
2872	<	fi
2873	<	fi
2874	<	acx_mpi_mpicxx=$ac_cv_prog_acx_mpi_mpicxx
2875	<	if test -n "$acx_mpi_mpicxx"; then
2876	<	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicxx" >&5
2877	<	$as_echo "$acx_mpi_mpicxx" >&6; }
2878	<	else
2879	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
2880	<	$as_echo "no" >&6; }
2881	<	fi
2882	<
2883	<
2884	<	test -n "$acx_mpi_mpicxx" && break
2885	<	done
2886	<	test -n "$acx_mpi_mpicxx" \|\| acx_mpi_mpicxx="no"
2887	<
2888	<	if test $acx_mpi_mpicxx != no; then
2889	<
2890	<	# Extract the first word of "$acx_mpi_mpicxx", so it can be a program name with args.
2891	<	set dummy $acx_mpi_mpicxx; ac_word=$2
2892	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2893	<	$as_echo_n "checking for $ac_word... " >&6; }
2894	<	if test "${ac_cv_path_acx_mpi_mpicxx_path+set}" = set; then
2895	<	$as_echo_n "(cached) " >&6
2896	<	else
2897	<	case $acx_mpi_mpicxx_path in
2898	<	[\\/]* \| ?:[\\/]*)
2899	<	ac_cv_path_acx_mpi_mpicxx_path="$acx_mpi_mpicxx_path" # Let the user override the test with a path.
2900	<	;;
2901	<	*)
2902	<	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2903	<	for as_dir in $PATH
2904	<	do
2905	<	IFS=$as_save_IFS
2906	<	test -z "$as_dir" && as_dir=.
2907	<	for ac_exec_ext in '' $ac_executable_extensions; do
2908	<	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2909	<	ac_cv_path_acx_mpi_mpicxx_path="$as_dir/$ac_word$ac_exec_ext"
2910	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2911	<	break 2
2912	<	fi
2913	<	done
2914	<	done
2915	<	IFS=$as_save_IFS
2916	<
2917	<	test -z "$ac_cv_path_acx_mpi_mpicxx_path" && ac_cv_path_acx_mpi_mpicxx_path="no"
2918	<	;;
2919	<	esac
2920	<	fi
2921	<	acx_mpi_mpicxx_path=$ac_cv_path_acx_mpi_mpicxx_path
2922	<	if test -n "$acx_mpi_mpicxx_path"; then
2923	<	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicxx_path" >&5
2924	<	$as_echo "$acx_mpi_mpicxx_path" >&6; }
2925	<	else
2926	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
2927	<	$as_echo "no" >&6; }
2928	<	fi
2929	<
2930	<
2931	<	fi
2932	<
2933	<	if test $acx_mpi_mpicc = no; then
2934	<
2935	<	if test $acx_mpi_mpicxx = no; then
2936	<
2937	<	acx_mpi_compiler=no
2938	<
2939	<	else
2940	<
2941	<	acx_mpi_compiler=$acx_mpi_mpicxx
2942	<	acx_mpi_compiler_path=$acx_mpi_mpicxx_path
2943	<	fi
2944	<
2945	<
2946	<	else
2947	<
2948	<	if test $acx_mpi_mpicxx = no; then
2949	<
2950	<	acx_mpi_compiler=$acx_mpi_mpicc
2951	<	acx_mpi_compiler_path=$acx_mpi_mpicc_path
2952	<
2953	<	else
2954	<
2955	<	{ $as_echo "$as_me:$LINENO: checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx" >&5
2956	<	$as_echo_n "checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx... " >&6; }
2957	<	ac_ext=cpp
3410	>	ac_ext=cpp
3411		ac_cpp='$CXXCPP $CPPFLAGS'
3412		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3413		ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3414		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3415
2963	–	cat >conftest.$ac_ext <<_ACEOF
2964	–	/* confdefs.h. */
2965	–	_ACEOF
2966	–	cat confdefs.h >>conftest.$ac_ext
2967	–	cat >>conftest.$ac_ext <<_ACEOF
2968	–	/* end confdefs.h. */
2969	–
2970	–	#include <mpi.h>
2971	–
2972	–	int
2973	–	main ()
2974	–	{
2975	–
2976	–	MPI_Finalize();
2977	–
2978	–	;
2979	–	return 0;
2980	–	}
2981	–	_ACEOF
2982	–	if { (ac_try="$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5"
2983	–	case "(($ac_try" in
2984	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
2985	–	*) ac_try_echo=$ac_try;;
2986	–	esac
2987	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
2988	–	$as_echo "$ac_try_echo") >&5
2989	–	(eval "$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5") 2>conftest.er1
2990	–	ac_status=$?
2991	–	grep -v '^ *+' conftest.er1 >conftest.err
2992	–	rm -f conftest.er1
2993	–	cat conftest.err >&5
2994	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
2995	–	(exit $ac_status); } && {
2996	–	test -z "$ac_cxx_werror_flag" \|\|
2997	–	test ! -s conftest.err
2998	–	} && test -s conftest.$ac_objext; then
2999	–
3000	–	acx_mpi_compiler=$acx_mpi_mpicxx
3001	–	acx_mpi_compiler_path=$acx_mpi_mpicxx_path
3002	–
3003	–	else
3004	–
3005	–	acx_mpi_compiler=$acx_mpi_mpicc
3006	–	acx_mpi_compiler_path=$acx_mpi_mpicc_path
3007	–	fi
3008	–
3009	–	ac_ext=c
3010	–	ac_cpp='$CPP $CPPFLAGS'
3011	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3012	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3013	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3014	–
3015	–	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_compiler" >&5
3016	–	$as_echo "$acx_mpi_compiler" >&6; }
3017	–	fi
3018	–
3019	–	fi
3020	–
3021	–	{ $as_echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
3022	–	$as_echo_n "checking whether mpif.h is usable... " >&6; }
3023	–	ac_ext=${ac_fc_srcext-f}
3024	–	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
3025	–	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
3026	–	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3027	–
3028	–	ac_save_ext=$ac_ext
3029	–	ac_ext=F90
3030	–	rm -f conftest*
3031	–	cat >conftest.$ac_ext <<EOF
3032	–	program main
3033	–	include 'mpif.h'
3034	–	call MPI_Init
3035	–	end
3036	–	EOF
3037	–	if $acx_mpi_mpif90_path -c conftest.$ac_ext > conftest.out 2>&1 ; then
3038	–	acx_mpi_f90_compiler=yes
3039	–	{ $as_echo "$as_me:$LINENO: result: yes" >&5
3040	–	$as_echo "yes" >&6; }
3041	–	else
3042	–	if test -s conftest.out ; then
3043	–	cat conftest.out >> config.log
3044	–	fi
3045	–	acx_mpi_f90_compiler=no
3046	–	{ $as_echo "$as_me:$LINENO: result: no! Check MPI fortran include paths" >&5
3047	–	$as_echo "no! Check MPI fortran include paths" >&6; }
3048	–	fi
3049	–	rm -f conftest*
3050	–	ac_ext=$ac_save_ext
3051	–	ac_ext=c
3052	–	ac_cpp='$CPP $CPPFLAGS'
3053	–	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3054	–	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3055	–	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3056	–
3057	–	if test $acx_mpi_compiler = no \|\| test $acx_mpi_f90_compiler = no; then
3058	–
3059	–	acx_cv_mpi_implementation=no
3060	–	else
3061	–	{ $as_echo "$as_me:$LINENO: checking for the MPI implementation flavor" >&5
3062	–	$as_echo_n "checking for the MPI implementation flavor... " >&6; }
3063	–	if test "${acx_cv_mpi_implementation+set}" = set; then
3064	–	$as_echo_n "(cached) " >&6
3065	–	else
3066	–	acx_cv_mpi_implementation=no
3067	–	if { (ac_try="grep -q LAM $acx_mpi_compiler_path"
3068	–	case "(($ac_try" in
3069	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3070	–	*) ac_try_echo=$ac_try;;
3071	–	esac
3072	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3073	–	$as_echo "$ac_try_echo") >&5
3074	–	(eval "grep -q LAM $acx_mpi_compiler_path") 2>conftest.er1
3075	–	ac_status=$?
3076	–	grep -v '^ *+' conftest.er1 >conftest.err
3077	–	rm -f conftest.er1
3078	–	cat conftest.err >&5
3079	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3080	–	(exit $ac_status); }; then
3081	–
3082	–	acx_cv_mpi_implementation=lammpi
3083	–
3084	–	else
3085	–
3086	–	if { (ac_try="grep -q showme $acx_mpi_compiler_path"
3087	–	case "(($ac_try" in
3088	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3089	–	*) ac_try_echo=$ac_try;;
3090	–	esac
3091	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3092	–	$as_echo "$ac_try_echo") >&5
3093	–	(eval "grep -q showme $acx_mpi_compiler_path") 2>conftest.er1
3094	–	ac_status=$?
3095	–	grep -v '^ *+' conftest.er1 >conftest.err
3096	–	rm -f conftest.er1
3097	–	cat conftest.err >&5
3098	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3099	–	(exit $ac_status); }; then
3100	–
3101	–	acx_cv_mpi_implementation=openmpi
3102	–
3103	–	else
3104	–
3105	–	if { (ac_try="grep -q MPICH $acx_mpi_compiler_path"
3106	–	case "(($ac_try" in
3107	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3108	–	*) ac_try_echo=$ac_try;;
3109	–	esac
3110	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3111	–	$as_echo "$ac_try_echo") >&5
3112	–	(eval "grep -q MPICH $acx_mpi_compiler_path") 2>conftest.er1
3113	–	ac_status=$?
3114	–	grep -v '^ *+' conftest.er1 >conftest.err
3115	–	rm -f conftest.er1
3116	–	cat conftest.err >&5
3117	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3118	–	(exit $ac_status); }; then
3119	–
3120	–	acx_cv_mpi_implementation=mpich
3121	–
3122	–	else
3123	–	acx_cv_mpi_implementation=$with_mpi
3124	–	fi
3125	–
3126	–	fi
3127	–
3128	–	fi
3129	–
3130	–	fi
3131	–	{ $as_echo "$as_me:$LINENO: result: $acx_cv_mpi_implementation" >&5
3132	–	$as_echo "$acx_cv_mpi_implementation" >&6; }
3133	–
3134	–	fi
3135	–	case $acx_cv_mpi_implementation in
3136	–	(lammpi)
3137	–
3138	–	cat >>confdefs.h <<\_ACEOF
3139	–	#define MPI_IS_LAMMPI 1
3140	–	_ACEOF
3141	–
3142	–	;;
3143	–	(openmpi)
3144	–
3145	–	cat >>confdefs.h <<\_ACEOF
3146	–	#define MPI_IS_OPENMPI 1
3147	–	_ACEOF
3148	–
3149	–	;;
3150	–	(mpich)
3151	–
3152	–	cat >>confdefs.h <<\_ACEOF
3153	–	#define MPI_IS_MPICH 1
3154	–	_ACEOF
3155	–
3156	–	;;
3157	–	esac
3158	–	if test $acx_cv_mpi_implementation = no; then
3159	–
3160	–	acx_mpi_cflags=""
3161	–	acx_mpi_libs=""
3162	–	USE_MPI="no"
3163	–	{ $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
3164	–	$as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
3165	–	else
3166	–
3167	–
3168	–	{ $as_echo "$as_me:$LINENO: checking how to compile MPI-C code" >&5
3169	–	$as_echo_n "checking how to compile MPI-C code... " >&6; }
3170	–	if test "${acx_mpi_cflags+set}" = set; then
3171	–	$as_echo_n "(cached) " >&6
3172	–	else
3173	–
3174	–	case $acx_cv_mpi_implementation in
3175	–	(lammpi)
3176	–	cfo="--showme:compile"
3177	–	;;
3178	–	(openmpi)
3179	–	cfo="--showme:compile"
3180	–	;;
3181	–	(mpich)
3182	–	case "$acx_mpi_compiler_path" in
3183	–	(*mpiCC)
3184	–	sc_cv_cn="-CC="
3185	–	;;
3186	–	(*mpicxx)
3187	–	sc_cv_cn="-cxx="
3188	–	;;
3189	–	(*mpicc)
3190	–	sc_cv_cn="-cc="
3191	–	;;
3192	–	(*)
3193	–	sc_cv_cn=""
3194	–	;;
3195	–	esac
3196	–	cfo="-compile_info $sc_cv_cn"
3197	–	;;
3198	–	esac
3199	–	$as_echo "$as_me:$LINENO: mpi_pre_cflags=\"\`$acx_mpi_compiler_path $cfo \|\| echo ' no'\`\"" >&5
3200	–	mpi_pre_cflags="`$acx_mpi_compiler_path $cfo 2>conftest.er1 \|\| echo ' no'`"
3201	–	grep -v '^ *+' conftest.er1 >conftest.err
3202	–	rm -f conftest.er1
3203	–	cat conftest.err >&5
3204	–	$as_echo "$as_me:$LINENO: mpi_pre_cflags = $mpi_pre_cflags" >&5
3205	–	case "$mpi_pre_cflags" in
3206	–	(*no)
3207	–	acx_mpi_cflags=no
3208	–	acx_mpi_cflags="no"
3209	–	;;
3210	–	(*)
3211	–	acx_mpi_tmp_mode="normal"
3212	–	acx_mpi_tmp_prefix=""
3213	–	eval "acx_mpi_cflags=\"\""
3214	–	for acx_mpi_tmp in $mpi_pre_cflags; do
3215	–	case "$acx_mpi_tmp_mode" in
3216	–	(normal)
3217	–	case "$acx_mpi_tmp" in
3218	–	(-I\|-D)
3219	–	acx_mpi_tmp_prefix="$acx_mpi_tmp"
3220	–	acx_mpi_tmp_mode="accept"
3221	–	;;
3222	–	(-I\|-D)
3223	–	eval "acx_mpi_cflags=\"`eval 'as_val=${'\\acx_mpi_cflags'}
3224	–	$as_echo "$as_val"'` \$acx_mpi_tmp\""
3225	–	;;
3226	–	(-L\|-l)
3227	–	acx_mpi_tmp_mode="skip"
3228	–	;;
3229	–	(*)
3230	–	;;
3231	–	esac
3232	–	;;
3233	–	(accept)
3234	–	eval "acx_mpi_cflags=\"`eval 'as_val=${'\\acx_mpi_cflags'}
3235	–	$as_echo "$as_val"'` \$acx_mpi_tmp_prefix \$acx_mpi_tmp\""
3236	–	;;
3237	–	(skip)
3238	–	;;
3239	–	esac
3240	–	done
3241	–
3242	–	;;
3243	–	esac
3244	–
3245	–	fi
3246	–	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_cflags" >&5
3247	–	$as_echo "$acx_mpi_cflags" >&6; }
3248	–
3249	–
3250	–	{ $as_echo "$as_me:$LINENO: checking how to link MPI-C code" >&5
3251	–	$as_echo_n "checking how to link MPI-C code... " >&6; }
3252	–	if test "${acx_mpi_libs+set}" = set; then
3253	–	$as_echo_n "(cached) " >&6
3254	–	else
3255	–
3256	–	case $acx_cv_mpi_implementation in
3257	–	(lammpi)
3258	–	lfo="--showme:compile --showme:link"
3259	–	;;
3260	–	(openmpi)
3261	–	lfo="--showme:link"
3262	–	;;
3263	–	(mpich)
3264	–	case "$acx_mpi_compiler_path" in
3265	–	(*mpiCC)
3266	–	sc_cv_cn="-CC="
3267	–	;;
3268	–	(*mpicxx)
3269	–	sc_cv_cn="-cxx="
3270	–	;;
3271	–	(*mpicc)
3272	–	sc_cv_cn="-cc="
3273	–	;;
3274	–	(*)
3275	–	sc_cv_cn=""
3276	–	;;
3277	–	esac
3278	–	lfo="-link_info $sc_cv_cn"
3279	–	;;
3280	–	esac
3281	–	$as_echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_compiler_path $lfo \|\| echo ' no'\`\"" >&5
3282	–	mpi_pre_libs="`$acx_mpi_compiler_path $lfo 2>conftest.er1 \|\| echo ' no'`"
3283	–	grep -v '^ *+' conftest.er1 >conftest.err
3284	–	rm -f conftest.er1
3285	–	cat conftest.err >&5
3286	–	$as_echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
3287	–	case "$mpi_pre_libs" in
3288	–	(*no)
3289	–	acx_mpi_libs=no
3290	–	;;
3291	–	(*)
3292	–	acx_mpi_libs="$mpi_pre_libs"
3293	–	;;
3294	–	esac
3295	–
3296	–	fi
3297	–	{ $as_echo "$as_me:$LINENO: result: $acx_mpi_libs" >&5
3298	–	$as_echo "$acx_mpi_libs" >&6; }
3299	–
3300	–	if test $acx_mpi_mpif90_path != no; then
3301	–
3302	–
3303	–	{ $as_echo "$as_me:$LINENO: checking how to link MPI-Fortran code" >&5
3304	–	$as_echo_n "checking how to link MPI-Fortran code... " >&6; }
3305	–	if test "${acx_mpi90_libs+set}" = set; then
3306	–	$as_echo_n "(cached) " >&6
3307	–	else
3308	–
3309	–	$as_echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_mpif90_path $lfo \|\| echo \" no\"\`\"" >&5
3310	–	mpi_pre_libs="`$acx_mpi_mpif90_path $lfo 2>conftest.er1 \|\| echo " no"`"
3311	–	grep -v '^ *+' conftest.er1 >conftest.err
3312	–	rm -f conftest.er1
3313	–	cat conftest.err >&5
3314	–	$as_echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
3315	–	case "$mpi_pre_libs" in
3316	–	(*no)
3317	–	acx_mpi90_libs=no
3318	–	;;
3319	–	(*)
3320	–	acx_mpi90_libs="$mpi_pre_libs"
3321	–	;;
3322	–	esac
3323	–
3324	–	fi
3325	–	{ $as_echo "$as_me:$LINENO: result: $acx_mpi90_libs" >&5
3326	–	$as_echo "$acx_mpi90_libs" >&6; }
3327	–
3328	–
3329	–	fi
3330	–
3331	–	if test "$acx_mpi_cflags" = no -o "$acx_mpi_libs" = no; then
3332	–
3333	–	acx_mpi_cflags=""
3334	–	acx_mpi_libs=""
3335	–	USE_MPI="no"
3336	–	{ $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
3337	–	$as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
3338	–	else
3339	–
3340	–	MPI_CPPFLAGS=$acx_mpi_cflags
3341	–
3342	–	MPI_LIBS=$acx_mpi_libs
3343	–
3344	–	if test "$acx_mpi90_libs" != no; then
3345	–	MPI90_LIBS=$acx_mpi90_libs
3346	–
3347	–	fi
3348	–
3349	–	USE_MPI="yes"
3350	–	fi
3351	–
3352	–
3353	–	fi
3354	–
3355	–
3356	–	fi
3357	–
3358	–
3359	–
3360	–	# Checks for programs.
3416		ac_ext=cpp
3417		ac_cpp='$CXXCPP $CPPFLAGS'
3418		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 3368 \| Line 3423 \| if test -z "$CXX"; then
3423		CXX=$CCC
3424		else
3425		if test -n "$ac_tool_prefix"; then
3426	<	for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
3426	>	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3427		do
3428		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3429		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3430	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3430	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3431		$as_echo_n "checking for $ac_word... " >&6; }
3432	<	if test "${ac_cv_prog_CXX+set}" = set; then
3432	>	if test "${ac_cv_prog_CXX+set}" = set; then :
3433		$as_echo_n "(cached) " >&6
3434		else
3435		if test -n "$CXX"; then
#	Line 3385 \| Line 3440 \| do
3440		do
3441		IFS=$as_save_IFS
3442		test -z "$as_dir" && as_dir=.
3443	<	for ac_exec_ext in '' $ac_executable_extensions; do
3443	>	for ac_exec_ext in '' $ac_executable_extensions; do
3444		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3445		ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3446	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3446	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3447		break 2
3448		fi
3449		done
3450	<	done
3450	>	done
3451		IFS=$as_save_IFS
3452
3453		fi
3454		fi
3455		CXX=$ac_cv_prog_CXX
3456		if test -n "$CXX"; then
3457	<	{ $as_echo "$as_me:$LINENO: result: $CXX" >&5
3457	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
3458		$as_echo "$CXX" >&6; }
3459		else
3460	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3460	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3461		$as_echo "no" >&6; }
3462		fi
3463
#	Line 3412 \| Line 3467 \| if test -z "$CXX"; then
3467		fi
3468		if test -z "$CXX"; then
3469		ac_ct_CXX=$CXX
3470	<	for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
3470	>	for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3471		do
3472		# Extract the first word of "$ac_prog", so it can be a program name with args.
3473		set dummy $ac_prog; ac_word=$2
3474	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3474	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3475		$as_echo_n "checking for $ac_word... " >&6; }
3476	<	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3476	>	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
3477		$as_echo_n "(cached) " >&6
3478		else
3479		if test -n "$ac_ct_CXX"; then
#	Line 3429 \| Line 3484 \| do
3484		do
3485		IFS=$as_save_IFS
3486		test -z "$as_dir" && as_dir=.
3487	<	for ac_exec_ext in '' $ac_executable_extensions; do
3487	>	for ac_exec_ext in '' $ac_executable_extensions; do
3488		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3489		ac_cv_prog_ac_ct_CXX="$ac_prog"
3490	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3490	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3491		break 2
3492		fi
3493		done
3494	<	done
3494	>	done
3495		IFS=$as_save_IFS
3496
3497		fi
3498		fi
3499		ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3500		if test -n "$ac_ct_CXX"; then
3501	<	{ $as_echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3501	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
3502		$as_echo "$ac_ct_CXX" >&6; }
3503		else
3504	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
3504	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3505		$as_echo "no" >&6; }
3506		fi
3507
#	Line 3459 \| Line 3514 \| yes:)
3514		else
3515		case $cross_compiling:$ac_tool_warned in
3516		yes:)
3517	<	{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
3518	<	whose name does not start with the host triplet. If you think this
3464	<	configuration is useful to you, please write to autoconf@gnu.org." >&5
3465	<	$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
3466	<	whose name does not start with the host triplet. If you think this
3467	<	configuration is useful to you, please write to autoconf@gnu.org." >&2;}
3517	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3518	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3519		ac_tool_warned=yes ;;
3520		esac
3521		CXX=$ac_ct_CXX
#	Line 3474 \| Line 3525 \| fi
3525		fi
3526		fi
3527		# Provide some information about the compiler.
3528	<	$as_echo "$as_me:$LINENO: checking for C++ compiler version" >&5
3528	>	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3529		set X $ac_compile
3530		ac_compiler=$2
3531	<	{ (ac_try="$ac_compiler --version >&5"
3531	>	for ac_option in --version -v -V -qversion; do
3532	>	{ { ac_try="$ac_compiler $ac_option >&5"
3533		case "(($ac_try" in
3534		\" \| \` \| \\) ac_try_echo=\$ac_try;;
3535		*) ac_try_echo=$ac_try;;
3536		esac
3537	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3538	<	$as_echo "$ac_try_echo") >&5
3539	<	(eval "$ac_compiler --version >&5") 2>&5
3537	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3538	>	$as_echo "$ac_try_echo"; } >&5
3539	>	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
3540		ac_status=$?
3541	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3542	<	(exit $ac_status); }
3543	<	{ (ac_try="$ac_compiler -v >&5"
3544	<	case "(($ac_try" in
3545	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3546	<	*) ac_try_echo=$ac_try;;
3547	<	esac
3548	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3549	<	$as_echo "$ac_try_echo") >&5
3550	<	(eval "$ac_compiler -v >&5") 2>&5
3499	<	ac_status=$?
3500	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3501	<	(exit $ac_status); }
3502	<	{ (ac_try="$ac_compiler -V >&5"
3503	<	case "(($ac_try" in
3504	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3505	<	*) ac_try_echo=$ac_try;;
3506	<	esac
3507	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3508	<	$as_echo "$ac_try_echo") >&5
3509	<	(eval "$ac_compiler -V >&5") 2>&5
3510	<	ac_status=$?
3511	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3512	<	(exit $ac_status); }
3541	>	if test -s conftest.err; then
3542	>	sed '10a\
3543	>	... rest of stderr output deleted ...
3544	>	10q' conftest.err >conftest.er1
3545	>	cat conftest.er1 >&5
3546	>	rm -f conftest.er1 conftest.err
3547	>	fi
3548	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3549	>	test $ac_status = 0; }
3550	>	done
3551
3552	<	cat >conftest.$ac_ext <<_ACEOF
3515	<	/* confdefs.h. */
3516	<	_ACEOF
3517	<	cat confdefs.h >>conftest.$ac_ext
3518	<	cat >>conftest.$ac_ext <<_ACEOF
3552	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3553		/* end confdefs.h. */
3554	<
3554	>	#include <stdio.h>
3555		int
3556		main ()
3557		{
3558	+	FILE *f = fopen ("conftest.out", "w");
3559	+	return ferror (f) \|\| fclose (f) != 0;
3560
3561		;
3562		return 0;
3563		}
3564		_ACEOF
3565		ac_clean_files_save=$ac_clean_files
3566	<	ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3566	>	ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out conftest.out"
3567		# Try to create an executable without -o first, disregard a.out.
3568		# It will help us diagnose broken compilers, and finding out an intuition
3569		# of exeext.
3570	<	{ $as_echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
3570	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3571		$as_echo_n "checking for C++ compiler default output file name... " >&6; }
3572		ac_link_default=`$as_echo "$ac_link" \| sed 's/ -o conftest[^ ]//'`
3573
#	Line 3548 \| Line 3584 \| rm -f $ac_rmfiles
3584		done
3585		rm -f $ac_rmfiles
3586
3587	<	if { (ac_try="$ac_link_default"
3587	>	if { { ac_try="$ac_link_default"
3588		case "(($ac_try" in
3589		\" \| \` \| \\) ac_try_echo=\$ac_try;;
3590		*) ac_try_echo=$ac_try;;
3591		esac
3592	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3593	<	$as_echo "$ac_try_echo") >&5
3592	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3593	>	$as_echo "$ac_try_echo"; } >&5
3594		(eval "$ac_link_default") 2>&5
3595		ac_status=$?
3596	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3597	<	(exit $ac_status); }; then
3596	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3597	>	test $ac_status = 0; }; then :
3598		# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3599		# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3600		# in a Makefile. We should not override ac_cv_exeext if it was cached,
#	Line 3575 \| Line 3611 \| do
3611		# certainly right.
3612		break;;
3613		. )
3614	<	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3614	>	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3615		then :; else
3616		ac_cv_exeext=`expr "$ac_file" : '[^.]$\..$'`
3617		fi
#	Line 3594 \| Line 3630 \| fi
3630		else
3631		ac_file=''
3632		fi
3633	<
3598	<	{ $as_echo "$as_me:$LINENO: result: $ac_file" >&5
3633	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3634		$as_echo "$ac_file" >&6; }
3635	<	if test -z "$ac_file"; then
3635	>	if test -z "$ac_file"; then :
3636		$as_echo "$as_me: failed program was:" >&5
3637		sed 's/^/\| /' conftest.$ac_ext >&5
3638
3639	<	{ { $as_echo "$as_me:$LINENO: error: C++ compiler cannot create executables
3640	<	See \`config.log' for more details." >&5
3641	<	$as_echo "$as_me: error: C++ compiler cannot create executables
3642	<	See \`config.log' for more details." >&2;}
3643	<	{ (exit 77); exit 77; }; }
3639	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3640	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3641	>	{ as_fn_set_status 77
3642	>	as_fn_error "C++ compiler cannot create executables
3643	>	See \`config.log' for more details." "$LINENO" 5; }; }
3644		fi
3610	–
3645		ac_exeext=$ac_cv_exeext
3646
3647		# Check that the compiler produces executables we can run. If not, either
3648		# the compiler is broken, or we cross compile.
3649	<	{ $as_echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
3649	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3650		$as_echo_n "checking whether the C++ compiler works... " >&6; }
3617	–	# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3651		# If not cross compiling, check that we can run a simple program.
3652		if test "$cross_compiling" != yes; then
3653		if { ac_try='./$ac_file'
3654	<	{ (case "(($ac_try" in
3654	>	{ { case "(($ac_try" in
3655		\" \| \` \| \\) ac_try_echo=\$ac_try;;
3656		*) ac_try_echo=$ac_try;;
3657		esac
3658	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3659	<	$as_echo "$ac_try_echo") >&5
3658	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3659	>	$as_echo "$ac_try_echo"; } >&5
3660		(eval "$ac_try") 2>&5
3661		ac_status=$?
3662	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3663	<	(exit $ac_status); }; }; then
3662	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3663	>	test $ac_status = 0; }; }; then
3664		cross_compiling=no
3665		else
3666		if test "$cross_compiling" = maybe; then
3667		cross_compiling=yes
3668		else
3669	<	{ { $as_echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
3669	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3670	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3671	>	as_fn_error "cannot run C++ compiled programs.
3672		If you meant to cross compile, use \`--host'.
3673	<	See \`config.log' for more details." >&5
3639	<	$as_echo "$as_me: error: cannot run C++ compiled programs.
3640	<	If you meant to cross compile, use \`--host'.
3641	<	See \`config.log' for more details." >&2;}
3642	<	{ (exit 1); exit 1; }; }
3673	>	See \`config.log' for more details." "$LINENO" 5; }
3674		fi
3675		fi
3676		fi
3677	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
3677	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3678		$as_echo "yes" >&6; }
3679
3680	<	rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3680	>	rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out conftest.out
3681		ac_clean_files=$ac_clean_files_save
3682		# Check that the compiler produces executables we can run. If not, either
3683		# the compiler is broken, or we cross compile.
3684	<	{ $as_echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3684	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3685		$as_echo_n "checking whether we are cross compiling... " >&6; }
3686	<	{ $as_echo "$as_me:$LINENO: result: $cross_compiling" >&5
3686	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3687		$as_echo "$cross_compiling" >&6; }
3688
3689	<	{ $as_echo "$as_me:$LINENO: checking for suffix of executables" >&5
3689	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3690		$as_echo_n "checking for suffix of executables... " >&6; }
3691	<	if { (ac_try="$ac_link"
3691	>	if { { ac_try="$ac_link"
3692		case "(($ac_try" in
3693		\" \| \` \| \\) ac_try_echo=\$ac_try;;
3694		*) ac_try_echo=$ac_try;;
3695		esac
3696	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3697	<	$as_echo "$ac_try_echo") >&5
3696	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3697	>	$as_echo "$ac_try_echo"; } >&5
3698		(eval "$ac_link") 2>&5
3699		ac_status=$?
3700	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3701	<	(exit $ac_status); }; then
3700	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3701	>	test $ac_status = 0; }; then :
3702		# If both `conftest.exe' and `conftest' are `present' (well, observable)
3703		# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
3704		# work properly (i.e., refer to `conftest.exe'), while it won't with
#	Line 3682 \| Line 3713 \| else
3713		esac
3714		done
3715		else
3716	<	{ { $as_echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3717	<	See \`config.log' for more details." >&5
3718	<	$as_echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3719	<	See \`config.log' for more details." >&2;}
3689	<	{ (exit 1); exit 1; }; }
3716	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3717	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3718	>	as_fn_error "cannot compute suffix of executables: cannot compile and link
3719	>	See \`config.log' for more details." "$LINENO" 5; }
3720		fi
3691	–
3721		rm -f conftest$ac_cv_exeext
3722	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3722	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3723		$as_echo "$ac_cv_exeext" >&6; }
3724
3725		rm -f conftest.$ac_ext
3726		EXEEXT=$ac_cv_exeext
3727		ac_exeext=$EXEEXT
3728	<	{ $as_echo "$as_me:$LINENO: checking for suffix of object files" >&5
3728	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3729		$as_echo_n "checking for suffix of object files... " >&6; }
3730	<	if test "${ac_cv_objext+set}" = set; then
3730	>	if test "${ac_cv_objext+set}" = set; then :
3731		$as_echo_n "(cached) " >&6
3732		else
3733	<	cat >conftest.$ac_ext <<_ACEOF
3705	<	/* confdefs.h. */
3706	<	_ACEOF
3707	<	cat confdefs.h >>conftest.$ac_ext
3708	<	cat >>conftest.$ac_ext <<_ACEOF
3733	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3734		/* end confdefs.h. */
3735
3736		int
#	Line 3717 \| Line 3742 \| rm -f conftest.o conftest.obj
3742		}
3743		_ACEOF
3744		rm -f conftest.o conftest.obj
3745	<	if { (ac_try="$ac_compile"
3745	>	if { { ac_try="$ac_compile"
3746		case "(($ac_try" in
3747		\" \| \` \| \\) ac_try_echo=\$ac_try;;
3748		*) ac_try_echo=$ac_try;;
3749		esac
3750	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3751	<	$as_echo "$ac_try_echo") >&5
3750	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3751	>	$as_echo "$ac_try_echo"; } >&5
3752		(eval "$ac_compile") 2>&5
3753		ac_status=$?
3754	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3755	<	(exit $ac_status); }; then
3754	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3755	>	test $ac_status = 0; }; then :
3756		for ac_file in conftest.o conftest.obj conftest.*; do
3757		test -f "$ac_file" \|\| continue;
3758		case $ac_file in
#	Line 3740 \| Line 3765 \| sed 's/^/\| /' conftest.$ac_ext >&5
3765		$as_echo "$as_me: failed program was:" >&5
3766		sed 's/^/\| /' conftest.$ac_ext >&5
3767
3768	<	{ { $as_echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3769	<	See \`config.log' for more details." >&5
3770	<	$as_echo "$as_me: error: cannot compute suffix of object files: cannot compile
3771	<	See \`config.log' for more details." >&2;}
3747	<	{ (exit 1); exit 1; }; }
3768	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3769	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3770	>	as_fn_error "cannot compute suffix of object files: cannot compile
3771	>	See \`config.log' for more details." "$LINENO" 5; }
3772		fi
3749	–
3773		rm -f conftest.$ac_cv_objext conftest.$ac_ext
3774		fi
3775	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3775	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3776		$as_echo "$ac_cv_objext" >&6; }
3777		OBJEXT=$ac_cv_objext
3778		ac_objext=$OBJEXT
3779	<	{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3779	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3780		$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3781	<	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3781	>	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
3782		$as_echo_n "(cached) " >&6
3783		else
3784	<	cat >conftest.$ac_ext <<_ACEOF
3762	<	/* confdefs.h. */
3763	<	_ACEOF
3764	<	cat confdefs.h >>conftest.$ac_ext
3765	<	cat >>conftest.$ac_ext <<_ACEOF
3784	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3785		/* end confdefs.h. */
3786
3787		int
#	Line 3776 \| Line 3795 \| _ACEOF
3795		return 0;
3796		}
3797		_ACEOF
3798	<	rm -f conftest.$ac_objext
3780	<	if { (ac_try="$ac_compile"
3781	<	case "(($ac_try" in
3782	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3783	<	*) ac_try_echo=$ac_try;;
3784	<	esac
3785	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3786	<	$as_echo "$ac_try_echo") >&5
3787	<	(eval "$ac_compile") 2>conftest.er1
3788	<	ac_status=$?
3789	<	grep -v '^ *+' conftest.er1 >conftest.err
3790	<	rm -f conftest.er1
3791	<	cat conftest.err >&5
3792	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3793	<	(exit $ac_status); } && {
3794	<	test -z "$ac_cxx_werror_flag" \|\|
3795	<	test ! -s conftest.err
3796	<	} && test -s conftest.$ac_objext; then
3798	>	if ac_fn_cxx_try_compile "$LINENO"; then :
3799		ac_compiler_gnu=yes
3800		else
3801	<	$as_echo "$as_me: failed program was:" >&5
3800	<	sed 's/^/\| /' conftest.$ac_ext >&5
3801	<
3802	<	ac_compiler_gnu=no
3801	>	ac_compiler_gnu=no
3802		fi
3804	–
3803		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3804		ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3805
3806		fi
3807	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3807	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3808		$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3809		if test $ac_compiler_gnu = yes; then
3810		GXX=yes
#	Line 3815 \| Line 3813 \| ac_save_CXXFLAGS=$CXXFLAGS
3813		fi
3814		ac_test_CXXFLAGS=${CXXFLAGS+set}
3815		ac_save_CXXFLAGS=$CXXFLAGS
3816	<	{ $as_echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3816	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3817		$as_echo_n "checking whether $CXX accepts -g... " >&6; }
3818	<	if test "${ac_cv_prog_cxx_g+set}" = set; then
3818	>	if test "${ac_cv_prog_cxx_g+set}" = set; then :
3819		$as_echo_n "(cached) " >&6
3820		else
3821		ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3822		ac_cxx_werror_flag=yes
3823		ac_cv_prog_cxx_g=no
3824		CXXFLAGS="-g"
3825	<	cat >conftest.$ac_ext <<_ACEOF
3828	<	/* confdefs.h. */
3829	<	_ACEOF
3830	<	cat confdefs.h >>conftest.$ac_ext
3831	<	cat >>conftest.$ac_ext <<_ACEOF
3825	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3826		/* end confdefs.h. */
3827
3828		int
#	Line 3839 \| Line 3833 \| _ACEOF
3833		return 0;
3834		}
3835		_ACEOF
3836	<	rm -f conftest.$ac_objext
3843	<	if { (ac_try="$ac_compile"
3844	<	case "(($ac_try" in
3845	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3846	<	*) ac_try_echo=$ac_try;;
3847	<	esac
3848	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3849	<	$as_echo "$ac_try_echo") >&5
3850	<	(eval "$ac_compile") 2>conftest.er1
3851	<	ac_status=$?
3852	<	grep -v '^ *+' conftest.er1 >conftest.err
3853	<	rm -f conftest.er1
3854	<	cat conftest.err >&5
3855	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3856	<	(exit $ac_status); } && {
3857	<	test -z "$ac_cxx_werror_flag" \|\|
3858	<	test ! -s conftest.err
3859	<	} && test -s conftest.$ac_objext; then
3836	>	if ac_fn_cxx_try_compile "$LINENO"; then :
3837		ac_cv_prog_cxx_g=yes
3838		else
3839	<	$as_echo "$as_me: failed program was:" >&5
3840	<	sed 's/^/\| /' conftest.$ac_ext >&5
3864	<
3865	<	CXXFLAGS=""
3866	<	cat >conftest.$ac_ext <<_ACEOF
3867	<	/* confdefs.h. */
3868	<	_ACEOF
3869	<	cat confdefs.h >>conftest.$ac_ext
3870	<	cat >>conftest.$ac_ext <<_ACEOF
3839	>	CXXFLAGS=""
3840	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3841		/* end confdefs.h. */
3842
3843		int
#	Line 3878 \| Line 3848 \| _ACEOF
3848		return 0;
3849		}
3850		_ACEOF
3851	<	rm -f conftest.$ac_objext
3882	<	if { (ac_try="$ac_compile"
3883	<	case "(($ac_try" in
3884	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3885	<	*) ac_try_echo=$ac_try;;
3886	<	esac
3887	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3888	<	$as_echo "$ac_try_echo") >&5
3889	<	(eval "$ac_compile") 2>conftest.er1
3890	<	ac_status=$?
3891	<	grep -v '^ *+' conftest.er1 >conftest.err
3892	<	rm -f conftest.er1
3893	<	cat conftest.err >&5
3894	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3895	<	(exit $ac_status); } && {
3896	<	test -z "$ac_cxx_werror_flag" \|\|
3897	<	test ! -s conftest.err
3898	<	} && test -s conftest.$ac_objext; then
3899	<	:
3900	<	else
3901	<	$as_echo "$as_me: failed program was:" >&5
3902	<	sed 's/^/\| /' conftest.$ac_ext >&5
3851	>	if ac_fn_cxx_try_compile "$LINENO"; then :
3852
3853	<	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3853	>	else
3854	>	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3855		CXXFLAGS="-g"
3856	<	cat >conftest.$ac_ext <<_ACEOF
3907	<	/* confdefs.h. */
3908	<	_ACEOF
3909	<	cat confdefs.h >>conftest.$ac_ext
3910	<	cat >>conftest.$ac_ext <<_ACEOF
3856	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3857		/* end confdefs.h. */
3858
3859		int
#	Line 3918 \| Line 3864 \| _ACEOF
3864		return 0;
3865		}
3866		_ACEOF
3867	<	rm -f conftest.$ac_objext
3922	<	if { (ac_try="$ac_compile"
3923	<	case "(($ac_try" in
3924	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
3925	<	*) ac_try_echo=$ac_try;;
3926	<	esac
3927	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3928	<	$as_echo "$ac_try_echo") >&5
3929	<	(eval "$ac_compile") 2>conftest.er1
3930	<	ac_status=$?
3931	<	grep -v '^ *+' conftest.er1 >conftest.err
3932	<	rm -f conftest.er1
3933	<	cat conftest.err >&5
3934	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3935	<	(exit $ac_status); } && {
3936	<	test -z "$ac_cxx_werror_flag" \|\|
3937	<	test ! -s conftest.err
3938	<	} && test -s conftest.$ac_objext; then
3867	>	if ac_fn_cxx_try_compile "$LINENO"; then :
3868		ac_cv_prog_cxx_g=yes
3940	–	else
3941	–	$as_echo "$as_me: failed program was:" >&5
3942	–	sed 's/^/\| /' conftest.$ac_ext >&5
3943	–
3944	–
3869		fi
3946	–
3870		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3871		fi
3949	–
3872		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3873		fi
3952	–
3874		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3875		ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3876		fi
3877	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3877	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3878		$as_echo "$ac_cv_prog_cxx_g" >&6; }
3879		if test "$ac_test_CXXFLAGS" = set; then
3880		CXXFLAGS=$ac_save_CXXFLAGS
#	Line 3970 \| Line 3891 \| fi
3891		CXXFLAGS=
3892		fi
3893		fi
3894	<	ac_ext=c
3895	<	ac_cpp='$CPP $CPPFLAGS'
3896	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3897	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3898	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
3894	>	ac_ext=cpp
3895	>	ac_cpp='$CXXCPP $CPPFLAGS'
3896	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3897	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3898	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3899	>
3900	>
3901	>
3902	>
3903	>
3904	>
3905	>
3906	>	for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3907	>	do
3908	>	# Extract the first word of "$ac_prog", so it can be a program name with args.
3909	>	set dummy $ac_prog; ac_word=$2
3910	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3911	>	$as_echo_n "checking for $ac_word... " >&6; }
3912	>	if test "${ac_cv_prog_MPICXX+set}" = set; then :
3913	>	$as_echo_n "(cached) " >&6
3914	>	else
3915	>	if test -n "$MPICXX"; then
3916	>	ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3917	>	else
3918	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3919	>	for as_dir in $PATH
3920	>	do
3921	>	IFS=$as_save_IFS
3922	>	test -z "$as_dir" && as_dir=.
3923	>	for ac_exec_ext in '' $ac_executable_extensions; do
3924	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3925	>	ac_cv_prog_MPICXX="$ac_prog"
3926	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3927	>	break 2
3928	>	fi
3929	>	done
3930	>	done
3931	>	IFS=$as_save_IFS
3932	>
3933	>	fi
3934	>	fi
3935	>	MPICXX=$ac_cv_prog_MPICXX
3936	>	if test -n "$MPICXX"; then
3937	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3938	>	$as_echo "$MPICXX" >&6; }
3939	>	else
3940	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3941	>	$as_echo "no" >&6; }
3942	>	fi
3943	>
3944	>
3945	>	test -n "$MPICXX" && break
3946	>	done
3947	>	test -n "$MPICXX" \|\| MPICXX="$CXX"
3948	>
3949	>	ax_mpi_save_CXX="$CXX"
3950	>	CXX="$MPICXX"
3951	>
3952	>
3953	>
3954	>	if test x = x"$MPILIBS"; then
3955	>	ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3956	>	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
3957	>	MPILIBS=" "
3958	>	fi
3959
3960	+	fi
3961	+
3962	+	if test x = x"$MPILIBS"; then
3963	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3964	+	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3965	+	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
3966	+	$as_echo_n "(cached) " >&6
3967	+	else
3968	+	ac_check_lib_save_LIBS=$LIBS
3969	+	LIBS="-lmpi $LIBS"
3970	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3971	+	/* end confdefs.h. */
3972	+
3973	+	/* Override any GCC internal prototype to avoid an error.
3974	+	Use char because int might match the return type of a GCC
3975	+	builtin and then its argument prototype would still apply. */
3976	+	#ifdef __cplusplus
3977	+	extern "C"
3978	+	#endif
3979	+	char MPI_Init ();
3980	+	int
3981	+	main ()
3982	+	{
3983	+	return MPI_Init ();
3984	+	;
3985	+	return 0;
3986	+	}
3987	+	_ACEOF
3988	+	if ac_fn_cxx_try_link "$LINENO"; then :
3989	+	ac_cv_lib_mpi_MPI_Init=yes
3990	+	else
3991	+	ac_cv_lib_mpi_MPI_Init=no
3992	+	fi
3993	+	rm -f core conftest.err conftest.$ac_objext \
3994	+	conftest$ac_exeext conftest.$ac_ext
3995	+	LIBS=$ac_check_lib_save_LIBS
3996	+	fi
3997	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3998	+	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3999	+	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4000	+	MPILIBS="-lmpi"
4001	+	fi
4002	+
4003	+	fi
4004	+	if test x = x"$MPILIBS"; then
4005	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4006	+	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4007	+	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4008	+	$as_echo_n "(cached) " >&6
4009	+	else
4010	+	ac_check_lib_save_LIBS=$LIBS
4011	+	LIBS="-lmpich $LIBS"
4012	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4013	+	/* end confdefs.h. */
4014	+
4015	+	/* Override any GCC internal prototype to avoid an error.
4016	+	Use char because int might match the return type of a GCC
4017	+	builtin and then its argument prototype would still apply. */
4018	+	#ifdef __cplusplus
4019	+	extern "C"
4020	+	#endif
4021	+	char MPI_Init ();
4022	+	int
4023	+	main ()
4024	+	{
4025	+	return MPI_Init ();
4026	+	;
4027	+	return 0;
4028	+	}
4029	+	_ACEOF
4030	+	if ac_fn_cxx_try_link "$LINENO"; then :
4031	+	ac_cv_lib_mpich_MPI_Init=yes
4032	+	else
4033	+	ac_cv_lib_mpich_MPI_Init=no
4034	+	fi
4035	+	rm -f core conftest.err conftest.$ac_objext \
4036	+	conftest$ac_exeext conftest.$ac_ext
4037	+	LIBS=$ac_check_lib_save_LIBS
4038	+	fi
4039	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4040	+	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4041	+	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4042	+	MPILIBS="-lmpich"
4043	+	fi
4044	+
4045	+	fi
4046	+
4047	+	if test x != x"$MPILIBS"; then
4048	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4049	+	$as_echo_n "checking for mpi.h... " >&6; }
4050	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4051	+	/* end confdefs.h. */
4052	+	#include <mpi.h>
4053	+	int
4054	+	main ()
4055	+	{
4056	+
4057	+	;
4058	+	return 0;
4059	+	}
4060	+	_ACEOF
4061	+	if ac_fn_cxx_try_compile "$LINENO"; then :
4062	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4063	+	$as_echo "yes" >&6; }
4064	+	else
4065	+	MPILIBS=""
4066	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4067	+	$as_echo "no" >&6; }
4068	+	fi
4069	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4070	+	fi
4071	+
4072	+	CXX="$ax_mpi_save_CXX"
4073	+
4074	+
4075	+
4076	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4077	+	if test x = x"$MPILIBS"; then
4078	+	USE_MPI="no"
4079	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. oopse_MPI will not be built." >&5
4080	+	$as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. oopse_MPI will not be built." >&2;}
4081	+	:
4082	+	else
4083	+	USE_MPI="yes"
4084	+	:
4085	+	fi
4086	+
4087		ac_ext=c
4088		ac_cpp='$CPP $CPPFLAGS'
4089		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4090		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4091		ac_compiler_gnu=$ac_cv_c_compiler_gnu
4092		if test -n "$ac_tool_prefix"; then
4093	<	for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4093	>	# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
4094	>	set dummy ${ac_tool_prefix}gcc; ac_word=$2
4095	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4096	>	$as_echo_n "checking for $ac_word... " >&6; }
4097	>	if test "${ac_cv_prog_CC+set}" = set; then :
4098	>	$as_echo_n "(cached) " >&6
4099	>	else
4100	>	if test -n "$CC"; then
4101	>	ac_cv_prog_CC="$CC" # Let the user override the test.
4102	>	else
4103	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4104	>	for as_dir in $PATH
4105	>	do
4106	>	IFS=$as_save_IFS
4107	>	test -z "$as_dir" && as_dir=.
4108	>	for ac_exec_ext in '' $ac_executable_extensions; do
4109	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4110	>	ac_cv_prog_CC="${ac_tool_prefix}gcc"
4111	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4112	>	break 2
4113	>	fi
4114	>	done
4115	>	done
4116	>	IFS=$as_save_IFS
4117	>
4118	>	fi
4119	>	fi
4120	>	CC=$ac_cv_prog_CC
4121	>	if test -n "$CC"; then
4122	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4123	>	$as_echo "$CC" >&6; }
4124	>	else
4125	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4126	>	$as_echo "no" >&6; }
4127	>	fi
4128	>
4129	>
4130	>	fi
4131	>	if test -z "$ac_cv_prog_CC"; then
4132	>	ac_ct_CC=$CC
4133	>	# Extract the first word of "gcc", so it can be a program name with args.
4134	>	set dummy gcc; ac_word=$2
4135	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4136	>	$as_echo_n "checking for $ac_word... " >&6; }
4137	>	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4138	>	$as_echo_n "(cached) " >&6
4139	>	else
4140	>	if test -n "$ac_ct_CC"; then
4141	>	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4142	>	else
4143	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4144	>	for as_dir in $PATH
4145	>	do
4146	>	IFS=$as_save_IFS
4147	>	test -z "$as_dir" && as_dir=.
4148	>	for ac_exec_ext in '' $ac_executable_extensions; do
4149	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4150	>	ac_cv_prog_ac_ct_CC="gcc"
4151	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4152	>	break 2
4153	>	fi
4154	>	done
4155	>	done
4156	>	IFS=$as_save_IFS
4157	>
4158	>	fi
4159	>	fi
4160	>	ac_ct_CC=$ac_cv_prog_ac_ct_CC
4161	>	if test -n "$ac_ct_CC"; then
4162	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4163	>	$as_echo "$ac_ct_CC" >&6; }
4164	>	else
4165	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4166	>	$as_echo "no" >&6; }
4167	>	fi
4168	>
4169	>	if test "x$ac_ct_CC" = x; then
4170	>	CC=""
4171	>	else
4172	>	case $cross_compiling:$ac_tool_warned in
4173	>	yes:)
4174	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4175	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4176	>	ac_tool_warned=yes ;;
4177	>	esac
4178	>	CC=$ac_ct_CC
4179	>	fi
4180	>	else
4181	>	CC="$ac_cv_prog_CC"
4182	>	fi
4183	>
4184	>	if test -z "$CC"; then
4185	>	if test -n "$ac_tool_prefix"; then
4186	>	# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
4187	>	set dummy ${ac_tool_prefix}cc; ac_word=$2
4188	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4189	>	$as_echo_n "checking for $ac_word... " >&6; }
4190	>	if test "${ac_cv_prog_CC+set}" = set; then :
4191	>	$as_echo_n "(cached) " >&6
4192	>	else
4193	>	if test -n "$CC"; then
4194	>	ac_cv_prog_CC="$CC" # Let the user override the test.
4195	>	else
4196	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4197	>	for as_dir in $PATH
4198	>	do
4199	>	IFS=$as_save_IFS
4200	>	test -z "$as_dir" && as_dir=.
4201	>	for ac_exec_ext in '' $ac_executable_extensions; do
4202	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4203	>	ac_cv_prog_CC="${ac_tool_prefix}cc"
4204	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4205	>	break 2
4206	>	fi
4207	>	done
4208	>	done
4209	>	IFS=$as_save_IFS
4210	>
4211	>	fi
4212	>	fi
4213	>	CC=$ac_cv_prog_CC
4214	>	if test -n "$CC"; then
4215	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4216	>	$as_echo "$CC" >&6; }
4217	>	else
4218	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4219	>	$as_echo "no" >&6; }
4220	>	fi
4221	>
4222	>
4223	>	fi
4224	>	fi
4225	>	if test -z "$CC"; then
4226	>	# Extract the first word of "cc", so it can be a program name with args.
4227	>	set dummy cc; ac_word=$2
4228	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4229	>	$as_echo_n "checking for $ac_word... " >&6; }
4230	>	if test "${ac_cv_prog_CC+set}" = set; then :
4231	>	$as_echo_n "(cached) " >&6
4232	>	else
4233	>	if test -n "$CC"; then
4234	>	ac_cv_prog_CC="$CC" # Let the user override the test.
4235	>	else
4236	>	ac_prog_rejected=no
4237	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4238	>	for as_dir in $PATH
4239	>	do
4240	>	IFS=$as_save_IFS
4241	>	test -z "$as_dir" && as_dir=.
4242	>	for ac_exec_ext in '' $ac_executable_extensions; do
4243	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4244	>	if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
4245	>	ac_prog_rejected=yes
4246	>	continue
4247	>	fi
4248	>	ac_cv_prog_CC="cc"
4249	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4250	>	break 2
4251	>	fi
4252	>	done
4253	>	done
4254	>	IFS=$as_save_IFS
4255	>
4256	>	if test $ac_prog_rejected = yes; then
4257	>	# We found a bogon in the path, so make sure we never use it.
4258	>	set dummy $ac_cv_prog_CC
4259	>	shift
4260	>	if test $# != 0; then
4261	>	# We chose a different compiler from the bogus one.
4262	>	# However, it has the same basename, so the bogon will be chosen
4263	>	# first if we set CC to just the basename; use the full file name.
4264	>	shift
4265	>	ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
4266	>	fi
4267	>	fi
4268	>	fi
4269	>	fi
4270	>	CC=$ac_cv_prog_CC
4271	>	if test -n "$CC"; then
4272	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4273	>	$as_echo "$CC" >&6; }
4274	>	else
4275	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4276	>	$as_echo "no" >&6; }
4277	>	fi
4278	>
4279	>
4280	>	fi
4281	>	if test -z "$CC"; then
4282	>	if test -n "$ac_tool_prefix"; then
4283	>	for ac_prog in cl.exe
4284		do
4285		# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4286		set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4287	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4287	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4288		$as_echo_n "checking for $ac_word... " >&6; }
4289	<	if test "${ac_cv_prog_CC+set}" = set; then
4289	>	if test "${ac_cv_prog_CC+set}" = set; then :
4290		$as_echo_n "(cached) " >&6
4291		else
4292		if test -n "$CC"; then
#	Line 3999 \| Line 4297 \| do
4297		do
4298		IFS=$as_save_IFS
4299		test -z "$as_dir" && as_dir=.
4300	<	for ac_exec_ext in '' $ac_executable_extensions; do
4300	>	for ac_exec_ext in '' $ac_executable_extensions; do
4301		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4302		ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4303	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4303	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4304		break 2
4305		fi
4306		done
4307	<	done
4307	>	done
4308		IFS=$as_save_IFS
4309
4310		fi
4311		fi
4312		CC=$ac_cv_prog_CC
4313		if test -n "$CC"; then
4314	<	{ $as_echo "$as_me:$LINENO: result: $CC" >&5
4314	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4315		$as_echo "$CC" >&6; }
4316		else
4317	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
4317	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4318		$as_echo "no" >&6; }
4319		fi
4320
#	Line 4026 \| Line 4324 \| if test -z "$CC"; then
4324		fi
4325		if test -z "$CC"; then
4326		ac_ct_CC=$CC
4327	<	for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4327	>	for ac_prog in cl.exe
4328		do
4329		# Extract the first word of "$ac_prog", so it can be a program name with args.
4330		set dummy $ac_prog; ac_word=$2
4331	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4331	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4332		$as_echo_n "checking for $ac_word... " >&6; }
4333	<	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
4333	>	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4334		$as_echo_n "(cached) " >&6
4335		else
4336		if test -n "$ac_ct_CC"; then
#	Line 4043 \| Line 4341 \| do
4341		do
4342		IFS=$as_save_IFS
4343		test -z "$as_dir" && as_dir=.
4344	<	for ac_exec_ext in '' $ac_executable_extensions; do
4344	>	for ac_exec_ext in '' $ac_executable_extensions; do
4345		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4346		ac_cv_prog_ac_ct_CC="$ac_prog"
4347	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4347	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4348		break 2
4349		fi
4350		done
4351	<	done
4351	>	done
4352		IFS=$as_save_IFS
4353
4354		fi
4355		fi
4356		ac_ct_CC=$ac_cv_prog_ac_ct_CC
4357		if test -n "$ac_ct_CC"; then
4358	<	{ $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
4358	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4359		$as_echo "$ac_ct_CC" >&6; }
4360		else
4361	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
4361	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4362		$as_echo "no" >&6; }
4363		fi
4364
#	Line 4073 \| Line 4371 \| yes:)
4371		else
4372		case $cross_compiling:$ac_tool_warned in
4373		yes:)
4374	<	{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4375	<	whose name does not start with the host triplet. If you think this
4078	<	configuration is useful to you, please write to autoconf@gnu.org." >&5
4079	<	$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
4080	<	whose name does not start with the host triplet. If you think this
4081	<	configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4374	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4375	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4376		ac_tool_warned=yes ;;
4377		esac
4378		CC=$ac_ct_CC
4379		fi
4380		fi
4381
4382	+	fi
4383
4089	–	test -z "$CC" && { { $as_echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
4090	–	See \`config.log' for more details." >&5
4091	–	$as_echo "$as_me: error: no acceptable C compiler found in \$PATH
4092	–	See \`config.log' for more details." >&2;}
4093	–	{ (exit 1); exit 1; }; }
4384
4385	+	test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4386	+	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4387	+	as_fn_error "no acceptable C compiler found in \$PATH
4388	+	See \`config.log' for more details." "$LINENO" 5; }
4389	+
4390		# Provide some information about the compiler.
4391	<	$as_echo "$as_me:$LINENO: checking for C compiler version" >&5
4391	>	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
4392		set X $ac_compile
4393		ac_compiler=$2
4394	<	{ (ac_try="$ac_compiler --version >&5"
4394	>	for ac_option in --version -v -V -qversion; do
4395	>	{ { ac_try="$ac_compiler $ac_option >&5"
4396		case "(($ac_try" in
4397		\" \| \` \| \\) ac_try_echo=\$ac_try;;
4398		*) ac_try_echo=$ac_try;;
4399		esac
4400	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4401	<	$as_echo "$ac_try_echo") >&5
4402	<	(eval "$ac_compiler --version >&5") 2>&5
4400	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4401	>	$as_echo "$ac_try_echo"; } >&5
4402	>	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
4403		ac_status=$?
4404	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4405	<	(exit $ac_status); }
4406	<	{ (ac_try="$ac_compiler -v >&5"
4407	<	case "(($ac_try" in
4408	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4409	<	*) ac_try_echo=$ac_try;;
4410	<	esac
4411	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4412	<	$as_echo "$ac_try_echo") >&5
4413	<	(eval "$ac_compiler -v >&5") 2>&5
4118	<	ac_status=$?
4119	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4120	<	(exit $ac_status); }
4121	<	{ (ac_try="$ac_compiler -V >&5"
4122	<	case "(($ac_try" in
4123	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4124	<	*) ac_try_echo=$ac_try;;
4125	<	esac
4126	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4127	<	$as_echo "$ac_try_echo") >&5
4128	<	(eval "$ac_compiler -V >&5") 2>&5
4129	<	ac_status=$?
4130	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4131	<	(exit $ac_status); }
4404	>	if test -s conftest.err; then
4405	>	sed '10a\
4406	>	... rest of stderr output deleted ...
4407	>	10q' conftest.err >conftest.er1
4408	>	cat conftest.er1 >&5
4409	>	rm -f conftest.er1 conftest.err
4410	>	fi
4411	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4412	>	test $ac_status = 0; }
4413	>	done
4414
4415	<	{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
4415	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4416		$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4417	<	if test "${ac_cv_c_compiler_gnu+set}" = set; then
4417	>	if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4418		$as_echo_n "(cached) " >&6
4419		else
4420	<	cat >conftest.$ac_ext <<_ACEOF
4139	<	/* confdefs.h. */
4140	<	_ACEOF
4141	<	cat confdefs.h >>conftest.$ac_ext
4142	<	cat >>conftest.$ac_ext <<_ACEOF
4420	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4421		/* end confdefs.h. */
4422
4423		int
#	Line 4153 \| Line 4431 \| _ACEOF
4431		return 0;
4432		}
4433		_ACEOF
4434	<	rm -f conftest.$ac_objext
4157	<	if { (ac_try="$ac_compile"
4158	<	case "(($ac_try" in
4159	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4160	<	*) ac_try_echo=$ac_try;;
4161	<	esac
4162	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4163	<	$as_echo "$ac_try_echo") >&5
4164	<	(eval "$ac_compile") 2>conftest.er1
4165	<	ac_status=$?
4166	<	grep -v '^ *+' conftest.er1 >conftest.err
4167	<	rm -f conftest.er1
4168	<	cat conftest.err >&5
4169	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4170	<	(exit $ac_status); } && {
4171	<	test -z "$ac_c_werror_flag" \|\|
4172	<	test ! -s conftest.err
4173	<	} && test -s conftest.$ac_objext; then
4434	>	if ac_fn_c_try_compile "$LINENO"; then :
4435		ac_compiler_gnu=yes
4436		else
4437	<	$as_echo "$as_me: failed program was:" >&5
4177	<	sed 's/^/\| /' conftest.$ac_ext >&5
4178	<
4179	<	ac_compiler_gnu=no
4437	>	ac_compiler_gnu=no
4438		fi
4181	–
4439		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4440		ac_cv_c_compiler_gnu=$ac_compiler_gnu
4441
4442		fi
4443	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
4443	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
4444		$as_echo "$ac_cv_c_compiler_gnu" >&6; }
4445		if test $ac_compiler_gnu = yes; then
4446		GCC=yes
#	Line 4192 \| Line 4449 \| ac_save_CFLAGS=$CFLAGS
4449		fi
4450		ac_test_CFLAGS=${CFLAGS+set}
4451		ac_save_CFLAGS=$CFLAGS
4452	<	{ $as_echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
4452	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
4453		$as_echo_n "checking whether $CC accepts -g... " >&6; }
4454	<	if test "${ac_cv_prog_cc_g+set}" = set; then
4454	>	if test "${ac_cv_prog_cc_g+set}" = set; then :
4455		$as_echo_n "(cached) " >&6
4456		else
4457		ac_save_c_werror_flag=$ac_c_werror_flag
4458		ac_c_werror_flag=yes
4459		ac_cv_prog_cc_g=no
4460		CFLAGS="-g"
4461	<	cat >conftest.$ac_ext <<_ACEOF
4205	<	/* confdefs.h. */
4206	<	_ACEOF
4207	<	cat confdefs.h >>conftest.$ac_ext
4208	<	cat >>conftest.$ac_ext <<_ACEOF
4461	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4462		/* end confdefs.h. */
4463
4464		int
#	Line 4216 \| Line 4469 \| _ACEOF
4469		return 0;
4470		}
4471		_ACEOF
4472	<	rm -f conftest.$ac_objext
4220	<	if { (ac_try="$ac_compile"
4221	<	case "(($ac_try" in
4222	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4223	<	*) ac_try_echo=$ac_try;;
4224	<	esac
4225	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4226	<	$as_echo "$ac_try_echo") >&5
4227	<	(eval "$ac_compile") 2>conftest.er1
4228	<	ac_status=$?
4229	<	grep -v '^ *+' conftest.er1 >conftest.err
4230	<	rm -f conftest.er1
4231	<	cat conftest.err >&5
4232	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4233	<	(exit $ac_status); } && {
4234	<	test -z "$ac_c_werror_flag" \|\|
4235	<	test ! -s conftest.err
4236	<	} && test -s conftest.$ac_objext; then
4472	>	if ac_fn_c_try_compile "$LINENO"; then :
4473		ac_cv_prog_cc_g=yes
4474		else
4475	<	$as_echo "$as_me: failed program was:" >&5
4476	<	sed 's/^/\| /' conftest.$ac_ext >&5
4241	<
4242	<	CFLAGS=""
4243	<	cat >conftest.$ac_ext <<_ACEOF
4244	<	/* confdefs.h. */
4245	<	_ACEOF
4246	<	cat confdefs.h >>conftest.$ac_ext
4247	<	cat >>conftest.$ac_ext <<_ACEOF
4475	>	CFLAGS=""
4476	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4477		/* end confdefs.h. */
4478
4479		int
#	Line 4255 \| Line 4484 \| _ACEOF
4484		return 0;
4485		}
4486		_ACEOF
4487	<	rm -f conftest.$ac_objext
4259	<	if { (ac_try="$ac_compile"
4260	<	case "(($ac_try" in
4261	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4262	<	*) ac_try_echo=$ac_try;;
4263	<	esac
4264	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4265	<	$as_echo "$ac_try_echo") >&5
4266	<	(eval "$ac_compile") 2>conftest.er1
4267	<	ac_status=$?
4268	<	grep -v '^ *+' conftest.er1 >conftest.err
4269	<	rm -f conftest.er1
4270	<	cat conftest.err >&5
4271	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4272	<	(exit $ac_status); } && {
4273	<	test -z "$ac_c_werror_flag" \|\|
4274	<	test ! -s conftest.err
4275	<	} && test -s conftest.$ac_objext; then
4276	<	:
4277	<	else
4278	<	$as_echo "$as_me: failed program was:" >&5
4279	<	sed 's/^/\| /' conftest.$ac_ext >&5
4487	>	if ac_fn_c_try_compile "$LINENO"; then :
4488
4489	<	ac_c_werror_flag=$ac_save_c_werror_flag
4489	>	else
4490	>	ac_c_werror_flag=$ac_save_c_werror_flag
4491		CFLAGS="-g"
4492	<	cat >conftest.$ac_ext <<_ACEOF
4284	<	/* confdefs.h. */
4285	<	_ACEOF
4286	<	cat confdefs.h >>conftest.$ac_ext
4287	<	cat >>conftest.$ac_ext <<_ACEOF
4492	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4493		/* end confdefs.h. */
4494
4495		int
#	Line 4295 \| Line 4500 \| _ACEOF
4500		return 0;
4501		}
4502		_ACEOF
4503	<	rm -f conftest.$ac_objext
4299	<	if { (ac_try="$ac_compile"
4300	<	case "(($ac_try" in
4301	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4302	<	*) ac_try_echo=$ac_try;;
4303	<	esac
4304	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4305	<	$as_echo "$ac_try_echo") >&5
4306	<	(eval "$ac_compile") 2>conftest.er1
4307	<	ac_status=$?
4308	<	grep -v '^ *+' conftest.er1 >conftest.err
4309	<	rm -f conftest.er1
4310	<	cat conftest.err >&5
4311	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4312	<	(exit $ac_status); } && {
4313	<	test -z "$ac_c_werror_flag" \|\|
4314	<	test ! -s conftest.err
4315	<	} && test -s conftest.$ac_objext; then
4503	>	if ac_fn_c_try_compile "$LINENO"; then :
4504		ac_cv_prog_cc_g=yes
4317	–	else
4318	–	$as_echo "$as_me: failed program was:" >&5
4319	–	sed 's/^/\| /' conftest.$ac_ext >&5
4320	–
4321	–
4505		fi
4323	–
4506		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4507		fi
4326	–
4508		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4509		fi
4329	–
4510		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4511		ac_c_werror_flag=$ac_save_c_werror_flag
4512		fi
4513	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
4513	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
4514		$as_echo "$ac_cv_prog_cc_g" >&6; }
4515		if test "$ac_test_CFLAGS" = set; then
4516		CFLAGS=$ac_save_CFLAGS
#	Line 4347 \| Line 4527 \| fi
4527		CFLAGS=
4528		fi
4529		fi
4530	<	{ $as_echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
4530	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
4531		$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
4532	<	if test "${ac_cv_prog_cc_c89+set}" = set; then
4532	>	if test "${ac_cv_prog_cc_c89+set}" = set; then :
4533		$as_echo_n "(cached) " >&6
4534		else
4535		ac_cv_prog_cc_c89=no
4536		ac_save_CC=$CC
4537	<	cat >conftest.$ac_ext <<_ACEOF
4358	<	/* confdefs.h. */
4359	<	_ACEOF
4360	<	cat confdefs.h >>conftest.$ac_ext
4361	<	cat >>conftest.$ac_ext <<_ACEOF
4537	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4538		/* end confdefs.h. */
4539		#include <stdarg.h>
4540		#include <stdio.h>
#	Line 4415 \| Line 4591 \| do
4591		-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
4592		do
4593		CC="$ac_save_CC $ac_arg"
4594	<	rm -f conftest.$ac_objext
4419	<	if { (ac_try="$ac_compile"
4420	<	case "(($ac_try" in
4421	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4422	<	*) ac_try_echo=$ac_try;;
4423	<	esac
4424	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4425	<	$as_echo "$ac_try_echo") >&5
4426	<	(eval "$ac_compile") 2>conftest.er1
4427	<	ac_status=$?
4428	<	grep -v '^ *+' conftest.er1 >conftest.err
4429	<	rm -f conftest.er1
4430	<	cat conftest.err >&5
4431	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4432	<	(exit $ac_status); } && {
4433	<	test -z "$ac_c_werror_flag" \|\|
4434	<	test ! -s conftest.err
4435	<	} && test -s conftest.$ac_objext; then
4594	>	if ac_fn_c_try_compile "$LINENO"; then :
4595		ac_cv_prog_cc_c89=$ac_arg
4437	–	else
4438	–	$as_echo "$as_me: failed program was:" >&5
4439	–	sed 's/^/\| /' conftest.$ac_ext >&5
4440	–
4441	–
4596		fi
4443	–
4597		rm -f core conftest.err conftest.$ac_objext
4598		test "x$ac_cv_prog_cc_c89" != "xno" && break
4599		done
#	Line 4451 \| Line 4604 \| case "x$ac_cv_prog_cc_c89" in
4604		# AC_CACHE_VAL
4605		case "x$ac_cv_prog_cc_c89" in
4606		x)
4607	<	{ $as_echo "$as_me:$LINENO: result: none needed" >&5
4607	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
4608		$as_echo "none needed" >&6; } ;;
4609		xno)
4610	<	{ $as_echo "$as_me:$LINENO: result: unsupported" >&5
4610	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
4611		$as_echo "unsupported" >&6; } ;;
4612		*)
4613		CC="$CC $ac_cv_prog_cc_c89"
4614	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
4614	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
4615		$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
4616		esac
4617	+	if test "x$ac_cv_prog_cc_c89" != xno; then :
4618
4619	+	fi
4620
4621		ac_ext=c
4622		ac_cpp='$CPP $CPPFLAGS'
#	Line 4469 \| Line 4624 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
4624		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4625		ac_compiler_gnu=$ac_cv_c_compiler_gnu
4626
4472	–	ac_ext=${ac_fc_srcext-f}
4473	–	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4474	–	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4475	–	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4476	–	if test -n "$ac_tool_prefix"; then
4477	–	for ac_prog in $FC $ac_cv_prog_acx_mpi_mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
4478	–	do
4479	–	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4480	–	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4481	–	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4482	–	$as_echo_n "checking for $ac_word... " >&6; }
4483	–	if test "${ac_cv_prog_FC+set}" = set; then
4484	–	$as_echo_n "(cached) " >&6
4485	–	else
4486	–	if test -n "$FC"; then
4487	–	ac_cv_prog_FC="$FC" # Let the user override the test.
4488	–	else
4489	–	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4490	–	for as_dir in $PATH
4491	–	do
4492	–	IFS=$as_save_IFS
4493	–	test -z "$as_dir" && as_dir=.
4494	–	for ac_exec_ext in '' $ac_executable_extensions; do
4495	–	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4496	–	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4497	–	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4498	–	break 2
4499	–	fi
4500	–	done
4501	–	done
4502	–	IFS=$as_save_IFS
4627
4628	<	fi
4505	<	fi
4506	<	FC=$ac_cv_prog_FC
4507	<	if test -n "$FC"; then
4508	<	{ $as_echo "$as_me:$LINENO: result: $FC" >&5
4509	<	$as_echo "$FC" >&6; }
4510	<	else
4511	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
4512	<	$as_echo "no" >&6; }
4513	<	fi
4628	>	if test $USE_MPI != no; then :
4629
4630	+	ac_ext=c
4631	+	ac_cpp='$CPP $CPPFLAGS'
4632	+	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4633	+	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4634	+	ac_compiler_gnu=$ac_cv_c_compiler_gnu
4635
4636	<	test -n "$FC" && break
4637	<	done
4638	<	fi
4639	<	if test -z "$FC"; then
4640	<	ac_ct_FC=$FC
4641	<	for ac_prog in $FC $ac_cv_prog_acx_mpi_mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
4636	>
4637	>
4638	>
4639	>
4640	>
4641	>	for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4642		do
4643		# Extract the first word of "$ac_prog", so it can be a program name with args.
4644		set dummy $ac_prog; ac_word=$2
4645	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4645	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4646		$as_echo_n "checking for $ac_word... " >&6; }
4647	<	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4647	>	if test "${ac_cv_prog_MPICC+set}" = set; then :
4648		$as_echo_n "(cached) " >&6
4649		else
4650	<	if test -n "$ac_ct_FC"; then
4651	<	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4650	>	if test -n "$MPICC"; then
4651	>	ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4652		else
4653		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4654		for as_dir in $PATH
4655		do
4656		IFS=$as_save_IFS
4657		test -z "$as_dir" && as_dir=.
4658	<	for ac_exec_ext in '' $ac_executable_extensions; do
4658	>	for ac_exec_ext in '' $ac_executable_extensions; do
4659		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4660	<	ac_cv_prog_ac_ct_FC="$ac_prog"
4661	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4660	>	ac_cv_prog_MPICC="$ac_prog"
4661	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4662		break 2
4663		fi
4664		done
4665	<	done
4665	>	done
4666		IFS=$as_save_IFS
4667
4668		fi
4669		fi
4670	<	ac_ct_FC=$ac_cv_prog_ac_ct_FC
4671	<	if test -n "$ac_ct_FC"; then
4672	<	{ $as_echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4673	<	$as_echo "$ac_ct_FC" >&6; }
4670	>	MPICC=$ac_cv_prog_MPICC
4671	>	if test -n "$MPICC"; then
4672	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4673	>	$as_echo "$MPICC" >&6; }
4674		else
4675	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
4675	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4676		$as_echo "no" >&6; }
4677		fi
4678
4679
4680	<	test -n "$ac_ct_FC" && break
4680	>	test -n "$MPICC" && break
4681		done
4682	+	test -n "$MPICC" \|\| MPICC="$CC"
4683
4684	<	if test "x$ac_ct_FC" = x; then
4685	<	FC=""
4565	<	else
4566	<	case $cross_compiling:$ac_tool_warned in
4567	<	yes:)
4568	<	{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4569	<	whose name does not start with the host triplet. If you think this
4570	<	configuration is useful to you, please write to autoconf@gnu.org." >&5
4571	<	$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
4572	<	whose name does not start with the host triplet. If you think this
4573	<	configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4574	<	ac_tool_warned=yes ;;
4575	<	esac
4576	<	FC=$ac_ct_FC
4577	<	fi
4578	<	fi
4684	>	ax_mpi_save_CC="$CC"
4685	>	CC="$MPICC"
4686
4687
4581	–	# Provide some information about the compiler.
4582	–	$as_echo "$as_me:$LINENO: checking for Fortran compiler version" >&5
4583	–	set X $ac_compile
4584	–	ac_compiler=$2
4585	–	{ (ac_try="$ac_compiler --version >&5"
4586	–	case "(($ac_try" in
4587	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4588	–	*) ac_try_echo=$ac_try;;
4589	–	esac
4590	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4591	–	$as_echo "$ac_try_echo") >&5
4592	–	(eval "$ac_compiler --version >&5") 2>&5
4593	–	ac_status=$?
4594	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4595	–	(exit $ac_status); }
4596	–	{ (ac_try="$ac_compiler -v >&5"
4597	–	case "(($ac_try" in
4598	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4599	–	*) ac_try_echo=$ac_try;;
4600	–	esac
4601	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4602	–	$as_echo "$ac_try_echo") >&5
4603	–	(eval "$ac_compiler -v >&5") 2>&5
4604	–	ac_status=$?
4605	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4606	–	(exit $ac_status); }
4607	–	{ (ac_try="$ac_compiler -V >&5"
4608	–	case "(($ac_try" in
4609	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4610	–	*) ac_try_echo=$ac_try;;
4611	–	esac
4612	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4613	–	$as_echo "$ac_try_echo") >&5
4614	–	(eval "$ac_compiler -V >&5") 2>&5
4615	–	ac_status=$?
4616	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4617	–	(exit $ac_status); }
4618	–	rm -f a.out
4688
4689	<	# If we don't use `.F' as extension, the preprocessor is not run on the
4690	<	# input file. (Note that this only needs to work for GNU compilers.)
4691	<	ac_save_ext=$ac_ext
4692	<	ac_ext=F
4693	<	{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4694	<	$as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4695	<	if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4689	>	if test x = x"$MPILIBS"; then
4690	>	ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4691	>	if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4692	>	MPILIBS=" "
4693	>	fi
4694	>
4695	>	fi
4696	>
4697	>	if test x = x"$MPILIBS"; then
4698	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4699	>	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4700	>	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4701		$as_echo_n "(cached) " >&6
4702		else
4703	<	cat >conftest.$ac_ext <<_ACEOF
4704	<	program main
4705	<	#ifndef __GNUC__
4706	<	choke me
4703	>	ac_check_lib_save_LIBS=$LIBS
4704	>	LIBS="-lmpi $LIBS"
4705	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4706	>	/* end confdefs.h. */
4707	>
4708	>	/* Override any GCC internal prototype to avoid an error.
4709	>	Use char because int might match the return type of a GCC
4710	>	builtin and then its argument prototype would still apply. */
4711	>	#ifdef __cplusplus
4712	>	extern "C"
4713	>	#endif
4714	>	char MPI_Init ();
4715	>	int
4716	>	main ()
4717	>	{
4718	>	return MPI_Init ();
4719	>	;
4720	>	return 0;
4721	>	}
4722	>	_ACEOF
4723	>	if ac_fn_c_try_link "$LINENO"; then :
4724	>	ac_cv_lib_mpi_MPI_Init=yes
4725	>	else
4726	>	ac_cv_lib_mpi_MPI_Init=no
4727	>	fi
4728	>	rm -f core conftest.err conftest.$ac_objext \
4729	>	conftest$ac_exeext conftest.$ac_ext
4730	>	LIBS=$ac_check_lib_save_LIBS
4731	>	fi
4732	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4733	>	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4734	>	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4735	>	MPILIBS="-lmpi"
4736	>	fi
4737	>
4738	>	fi
4739	>	if test x = x"$MPILIBS"; then
4740	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4741	>	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4742	>	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4743	>	$as_echo_n "(cached) " >&6
4744	>	else
4745	>	ac_check_lib_save_LIBS=$LIBS
4746	>	LIBS="-lmpich $LIBS"
4747	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4748	>	/* end confdefs.h. */
4749	>
4750	>	/* Override any GCC internal prototype to avoid an error.
4751	>	Use char because int might match the return type of a GCC
4752	>	builtin and then its argument prototype would still apply. */
4753	>	#ifdef __cplusplus
4754	>	extern "C"
4755	>	#endif
4756	>	char MPI_Init ();
4757	>	int
4758	>	main ()
4759	>	{
4760	>	return MPI_Init ();
4761	>	;
4762	>	return 0;
4763	>	}
4764	>	_ACEOF
4765	>	if ac_fn_c_try_link "$LINENO"; then :
4766	>	ac_cv_lib_mpich_MPI_Init=yes
4767	>	else
4768	>	ac_cv_lib_mpich_MPI_Init=no
4769	>	fi
4770	>	rm -f core conftest.err conftest.$ac_objext \
4771	>	conftest$ac_exeext conftest.$ac_ext
4772	>	LIBS=$ac_check_lib_save_LIBS
4773	>	fi
4774	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4775	>	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4776	>	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4777	>	MPILIBS="-lmpich"
4778	>	fi
4779	>
4780	>	fi
4781	>
4782	>	if test x != x"$MPILIBS"; then
4783	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4784	>	$as_echo_n "checking for mpi.h... " >&6; }
4785	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4786	>	/* end confdefs.h. */
4787	>	#include <mpi.h>
4788	>	int
4789	>	main ()
4790	>	{
4791	>
4792	>	;
4793	>	return 0;
4794	>	}
4795	>	_ACEOF
4796	>	if ac_fn_c_try_compile "$LINENO"; then :
4797	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4798	>	$as_echo "yes" >&6; }
4799	>	else
4800	>	MPILIBS=""
4801	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4802	>	$as_echo "no" >&6; }
4803	>	fi
4804	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4805	>	fi
4806	>
4807	>	CC="$ax_mpi_save_CC"
4808	>
4809	>
4810	>
4811	>	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4812	>	if test x = x"$MPILIBS"; then
4813	>	USE_MPI="no"
4814	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. oopse_MPI will not be built." >&5
4815	>	$as_echo "$as_me: WARNING: No suitable C MPI implementation found. oopse_MPI will not be built." >&2;}
4816	>	:
4817	>	else
4818	>	USE_MPI="yes"
4819	>	:
4820	>	fi
4821	>
4822	>
4823	>	fi
4824	>	ac_ext=${ac_fc_srcext-f}
4825	>	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4826	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4827	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4828	>	if test -n "$ac_tool_prefix"; then
4829	>	for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4830	>	do
4831	>	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4832	>	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4833	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4834	>	$as_echo_n "checking for $ac_word... " >&6; }
4835	>	if test "${ac_cv_prog_FC+set}" = set; then :
4836	>	$as_echo_n "(cached) " >&6
4837	>	else
4838	>	if test -n "$FC"; then
4839	>	ac_cv_prog_FC="$FC" # Let the user override the test.
4840	>	else
4841	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4842	>	for as_dir in $PATH
4843	>	do
4844	>	IFS=$as_save_IFS
4845	>	test -z "$as_dir" && as_dir=.
4846	>	for ac_exec_ext in '' $ac_executable_extensions; do
4847	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4848	>	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4849	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4850	>	break 2
4851	>	fi
4852	>	done
4853	>	done
4854	>	IFS=$as_save_IFS
4855	>
4856	>	fi
4857	>	fi
4858	>	FC=$ac_cv_prog_FC
4859	>	if test -n "$FC"; then
4860	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
4861	>	$as_echo "$FC" >&6; }
4862	>	else
4863	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4864	>	$as_echo "no" >&6; }
4865	>	fi
4866	>
4867	>
4868	>	test -n "$FC" && break
4869	>	done
4870	>	fi
4871	>	if test -z "$FC"; then
4872	>	ac_ct_FC=$FC
4873	>	for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4874	>	do
4875	>	# Extract the first word of "$ac_prog", so it can be a program name with args.
4876	>	set dummy $ac_prog; ac_word=$2
4877	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4878	>	$as_echo_n "checking for $ac_word... " >&6; }
4879	>	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
4880	>	$as_echo_n "(cached) " >&6
4881	>	else
4882	>	if test -n "$ac_ct_FC"; then
4883	>	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4884	>	else
4885	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4886	>	for as_dir in $PATH
4887	>	do
4888	>	IFS=$as_save_IFS
4889	>	test -z "$as_dir" && as_dir=.
4890	>	for ac_exec_ext in '' $ac_executable_extensions; do
4891	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4892	>	ac_cv_prog_ac_ct_FC="$ac_prog"
4893	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4894	>	break 2
4895	>	fi
4896	>	done
4897	>	done
4898	>	IFS=$as_save_IFS
4899	>
4900	>	fi
4901	>	fi
4902	>	ac_ct_FC=$ac_cv_prog_ac_ct_FC
4903	>	if test -n "$ac_ct_FC"; then
4904	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
4905	>	$as_echo "$ac_ct_FC" >&6; }
4906	>	else
4907	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4908	>	$as_echo "no" >&6; }
4909	>	fi
4910	>
4911	>
4912	>	test -n "$ac_ct_FC" && break
4913	>	done
4914	>
4915	>	if test "x$ac_ct_FC" = x; then
4916	>	FC=""
4917	>	else
4918	>	case $cross_compiling:$ac_tool_warned in
4919	>	yes:)
4920	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4921	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4922	>	ac_tool_warned=yes ;;
4923	>	esac
4924	>	FC=$ac_ct_FC
4925	>	fi
4926	>	fi
4927	>
4928	>
4929	>	# Provide some information about the compiler.
4930	>	$as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
4931	>	set X $ac_compile
4932	>	ac_compiler=$2
4933	>	for ac_option in --version -v -V -qversion; do
4934	>	{ { ac_try="$ac_compiler $ac_option >&5"
4935	>	case "(($ac_try" in
4936	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4937	>	*) ac_try_echo=$ac_try;;
4938	>	esac
4939	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4940	>	$as_echo "$ac_try_echo"; } >&5
4941	>	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
4942	>	ac_status=$?
4943	>	if test -s conftest.err; then
4944	>	sed '10a\
4945	>	... rest of stderr output deleted ...
4946	>	10q' conftest.err >conftest.er1
4947	>	cat conftest.er1 >&5
4948	>	rm -f conftest.er1 conftest.err
4949	>	fi
4950	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4951	>	test $ac_status = 0; }
4952	>	done
4953	>	rm -f a.out
4954	>
4955	>	# If we don't use `.F' as extension, the preprocessor is not run on the
4956	>	# input file. (Note that this only needs to work for GNU compilers.)
4957	>	ac_save_ext=$ac_ext
4958	>	ac_ext=F
4959	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
4960	>	$as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4961	>	if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
4962	>	$as_echo_n "(cached) " >&6
4963	>	else
4964	>	cat > conftest.$ac_ext <<_ACEOF
4965	>	program main
4966	>	#ifndef __GNUC__
4967	>	choke me
4968	>	#endif
4969	>
4970	>	end
4971	>	_ACEOF
4972	>	if ac_fn_fc_try_compile "$LINENO"; then :
4973	>	ac_compiler_gnu=yes
4974	>	else
4975	>	ac_compiler_gnu=no
4976	>	fi
4977	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4978	>	ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4979	>
4980	>	fi
4981	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
4982	>	$as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4983	>	ac_ext=$ac_save_ext
4984	>	ac_test_FCFLAGS=${FCFLAGS+set}
4985	>	ac_save_FCFLAGS=$FCFLAGS
4986	>	FCFLAGS=
4987	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
4988	>	$as_echo_n "checking whether $FC accepts -g... " >&6; }
4989	>	if test "${ac_cv_prog_fc_g+set}" = set; then :
4990	>	$as_echo_n "(cached) " >&6
4991	>	else
4992	>	FCFLAGS=-g
4993	>	cat > conftest.$ac_ext <<_ACEOF
4994	>	program main
4995	>
4996	>	end
4997	>	_ACEOF
4998	>	if ac_fn_fc_try_compile "$LINENO"; then :
4999	>	ac_cv_prog_fc_g=yes
5000	>	else
5001	>	ac_cv_prog_fc_g=no
5002	>	fi
5003	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5004	>
5005	>	fi
5006	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
5007	>	$as_echo "$ac_cv_prog_fc_g" >&6; }
5008	>	if test "$ac_test_FCFLAGS" = set; then
5009	>	FCFLAGS=$ac_save_FCFLAGS
5010	>	elif test $ac_cv_prog_fc_g = yes; then
5011	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
5012	>	FCFLAGS="-g -O2"
5013	>	else
5014	>	FCFLAGS="-g"
5015	>	fi
5016	>	else
5017	>	if test "x$ac_cv_fc_compiler_gnu" = xyes; then
5018	>	FCFLAGS="-O2"
5019	>	else
5020	>	FCFLAGS=
5021	>	fi
5022	>	fi
5023	>
5024	>	ac_ext=${ac_fc_srcext-f}
5025	>	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5026	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5027	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5028	>
5029	>
5030	>	if test $USE_MPI != no; then :
5031	>
5032	>	ac_ext=${ac_fc_srcext-f}
5033	>	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5034	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5035	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5036	>
5037	>
5038	>
5039	>
5040	>
5041	>
5042	>	for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
5043	>	do
5044	>	# Extract the first word of "$ac_prog", so it can be a program name with args.
5045	>	set dummy $ac_prog; ac_word=$2
5046	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5047	>	$as_echo_n "checking for $ac_word... " >&6; }
5048	>	if test "${ac_cv_prog_MPIFC+set}" = set; then :
5049	>	$as_echo_n "(cached) " >&6
5050	>	else
5051	>	if test -n "$MPIFC"; then
5052	>	ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
5053	>	else
5054	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5055	>	for as_dir in $PATH
5056	>	do
5057	>	IFS=$as_save_IFS
5058	>	test -z "$as_dir" && as_dir=.
5059	>	for ac_exec_ext in '' $ac_executable_extensions; do
5060	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5061	>	ac_cv_prog_MPIFC="$ac_prog"
5062	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5063	>	break 2
5064	>	fi
5065	>	done
5066	>	done
5067	>	IFS=$as_save_IFS
5068	>
5069	>	fi
5070	>	fi
5071	>	MPIFC=$ac_cv_prog_MPIFC
5072	>	if test -n "$MPIFC"; then
5073	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
5074	>	$as_echo "$MPIFC" >&6; }
5075	>	else
5076	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5077	>	$as_echo "no" >&6; }
5078	>	fi
5079	>
5080	>
5081	>	test -n "$MPIFC" && break
5082	>	done
5083	>	test -n "$MPIFC" \|\| MPIFC="$FC"
5084	>
5085	>	ax_mpi_save_FC="$FC"
5086	>	FC="$MPIFC"
5087	>
5088	>
5089	>
5090	>	if test x = x"$MPILIBS"; then
5091	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
5092	>	$as_echo_n "checking for MPI_Init... " >&6; }
5093	>	cat > conftest.$ac_ext <<_ACEOF
5094	>	program main
5095	>	call MPI_Init
5096	>	end
5097	>	_ACEOF
5098	>	if ac_fn_fc_try_link "$LINENO"; then :
5099	>	MPILIBS=" "
5100	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5101	>	$as_echo "yes" >&6; }
5102	>	else
5103	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5104	>	$as_echo "no" >&6; }
5105	>	fi
5106	>	rm -f core conftest.err conftest.$ac_objext \
5107	>	conftest$ac_exeext conftest.$ac_ext
5108	>	fi
5109	>
5110	>	if test x = x"$MPILIBS"; then
5111	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
5112	>	$as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
5113	>	if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
5114	>	$as_echo_n "(cached) " >&6
5115	>	else
5116	>	ac_check_lib_save_LIBS=$LIBS
5117	>	LIBS="-lfmpi $LIBS"
5118	>	cat > conftest.$ac_ext <<_ACEOF
5119	>	program main
5120	>	call MPI_Init
5121	>	end
5122	>	_ACEOF
5123	>	if ac_fn_fc_try_link "$LINENO"; then :
5124	>	ac_cv_lib_fmpi_MPI_Init=yes
5125	>	else
5126	>	ac_cv_lib_fmpi_MPI_Init=no
5127	>	fi
5128	>	rm -f core conftest.err conftest.$ac_objext \
5129	>	conftest$ac_exeext conftest.$ac_ext
5130	>	LIBS=$ac_check_lib_save_LIBS
5131	>	fi
5132	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
5133	>	$as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
5134	>	if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
5135	>	MPILIBS="-lfmpi"
5136	>	fi
5137	>
5138	>	fi
5139	>	if test x = x"$MPILIBS"; then
5140	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
5141	>	$as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
5142	>	if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
5143	>	$as_echo_n "(cached) " >&6
5144	>	else
5145	>	ac_check_lib_save_LIBS=$LIBS
5146	>	LIBS="-lmpichf90 $LIBS"
5147	>	cat > conftest.$ac_ext <<_ACEOF
5148	>	program main
5149	>	call MPI_Init
5150	>	end
5151	>	_ACEOF
5152	>	if ac_fn_fc_try_link "$LINENO"; then :
5153	>	ac_cv_lib_mpichf90_MPI_Init=yes
5154	>	else
5155	>	ac_cv_lib_mpichf90_MPI_Init=no
5156	>	fi
5157	>	rm -f core conftest.err conftest.$ac_objext \
5158	>	conftest$ac_exeext conftest.$ac_ext
5159	>	LIBS=$ac_check_lib_save_LIBS
5160	>	fi
5161	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
5162	>	$as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
5163	>	if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
5164	>	MPILIBS="-lmpichf90"
5165	>	fi
5166	>
5167	>	fi
5168	>
5169	>	if test x = x"$MPILIBS"; then
5170	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
5171	>	$as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
5172	>	if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
5173	>	$as_echo_n "(cached) " >&6
5174	>	else
5175	>	ac_check_lib_save_LIBS=$LIBS
5176	>	LIBS="-lmpi $LIBS"
5177	>	cat > conftest.$ac_ext <<_ACEOF
5178	>	program main
5179	>	call MPI_Init
5180	>	end
5181	>	_ACEOF
5182	>	if ac_fn_fc_try_link "$LINENO"; then :
5183	>	ac_cv_lib_mpi_MPI_Init=yes
5184	>	else
5185	>	ac_cv_lib_mpi_MPI_Init=no
5186	>	fi
5187	>	rm -f core conftest.err conftest.$ac_objext \
5188	>	conftest$ac_exeext conftest.$ac_ext
5189	>	LIBS=$ac_check_lib_save_LIBS
5190	>	fi
5191	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
5192	>	$as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
5193	>	if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
5194	>	MPILIBS="-lmpi"
5195	>	fi
5196	>
5197	>	fi
5198	>	if test x = x"$MPILIBS"; then
5199	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
5200	>	$as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
5201	>	if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
5202	>	$as_echo_n "(cached) " >&6
5203	>	else
5204	>	ac_check_lib_save_LIBS=$LIBS
5205	>	LIBS="-lmpich $LIBS"
5206	>	cat > conftest.$ac_ext <<_ACEOF
5207	>	program main
5208	>	call MPI_Init
5209	>	end
5210	>	_ACEOF
5211	>	if ac_fn_fc_try_link "$LINENO"; then :
5212	>	ac_cv_lib_mpich_MPI_Init=yes
5213	>	else
5214	>	ac_cv_lib_mpich_MPI_Init=no
5215	>	fi
5216	>	rm -f core conftest.err conftest.$ac_objext \
5217	>	conftest$ac_exeext conftest.$ac_ext
5218	>	LIBS=$ac_check_lib_save_LIBS
5219	>	fi
5220	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
5221	>	$as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
5222	>	if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
5223	>	MPILIBS="-lmpich"
5224	>	fi
5225	>
5226	>	fi
5227	>
5228	>	if test x != x"$MPILIBS"; then
5229	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
5230	>	$as_echo_n "checking for mpif.h... " >&6; }
5231	>	cat > conftest.$ac_ext <<_ACEOF
5232	>	program main
5233	>	include 'mpif.h'
5234	>	end
5235	>	_ACEOF
5236	>	if ac_fn_fc_try_compile "$LINENO"; then :
5237	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5238	>	$as_echo "yes" >&6; }
5239	>	else
5240	>	MPILIBS=""
5241	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5242	>	$as_echo "no" >&6; }
5243	>	fi
5244	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5245	>	fi
5246	>
5247	>	FC="$ax_mpi_save_FC"
5248	>
5249	>
5250	>
5251	>	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
5252	>	if test x = x"$MPILIBS"; then
5253	>	USE_MPI="no"
5254	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. oopse_MPI will not be built." >&5
5255	>	$as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. oopse_MPI will not be built." >&2;}
5256	>	:
5257	>	else
5258	>	USE_MPI="yes"
5259	>	:
5260	>	fi
5261	>
5262	>
5263	>	fi
5264	>	if test $USE_MPI != no; then :
5265	>
5266	>	CXX=$MPICXX
5267	>	CC=$MPICC
5268	>	FC=$MPIFC
5269	>
5270	>	fi
5271	>
5272	>
5273	>	# Checks for programs.
5274	>	ac_ext=cpp
5275	>	ac_cpp='$CXXCPP $CPPFLAGS'
5276	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5277	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5278	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5279	>	if test -z "$CXX"; then
5280	>	if test -n "$CCC"; then
5281	>	CXX=$CCC
5282	>	else
5283	>	if test -n "$ac_tool_prefix"; then
5284	>	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5285	>	do
5286	>	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5287	>	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5288	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5289	>	$as_echo_n "checking for $ac_word... " >&6; }
5290	>	if test "${ac_cv_prog_CXX+set}" = set; then :
5291	>	$as_echo_n "(cached) " >&6
5292	>	else
5293	>	if test -n "$CXX"; then
5294	>	ac_cv_prog_CXX="$CXX" # Let the user override the test.
5295	>	else
5296	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5297	>	for as_dir in $PATH
5298	>	do
5299	>	IFS=$as_save_IFS
5300	>	test -z "$as_dir" && as_dir=.
5301	>	for ac_exec_ext in '' $ac_executable_extensions; do
5302	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5303	>	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
5304	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5305	>	break 2
5306	>	fi
5307	>	done
5308	>	done
5309	>	IFS=$as_save_IFS
5310	>
5311	>	fi
5312	>	fi
5313	>	CXX=$ac_cv_prog_CXX
5314	>	if test -n "$CXX"; then
5315	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
5316	>	$as_echo "$CXX" >&6; }
5317	>	else
5318	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5319	>	$as_echo "no" >&6; }
5320	>	fi
5321	>
5322	>
5323	>	test -n "$CXX" && break
5324	>	done
5325	>	fi
5326	>	if test -z "$CXX"; then
5327	>	ac_ct_CXX=$CXX
5328	>	for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5329	>	do
5330	>	# Extract the first word of "$ac_prog", so it can be a program name with args.
5331	>	set dummy $ac_prog; ac_word=$2
5332	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5333	>	$as_echo_n "checking for $ac_word... " >&6; }
5334	>	if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
5335	>	$as_echo_n "(cached) " >&6
5336	>	else
5337	>	if test -n "$ac_ct_CXX"; then
5338	>	ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
5339	>	else
5340	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5341	>	for as_dir in $PATH
5342	>	do
5343	>	IFS=$as_save_IFS
5344	>	test -z "$as_dir" && as_dir=.
5345	>	for ac_exec_ext in '' $ac_executable_extensions; do
5346	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5347	>	ac_cv_prog_ac_ct_CXX="$ac_prog"
5348	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5349	>	break 2
5350	>	fi
5351	>	done
5352	>	done
5353	>	IFS=$as_save_IFS
5354	>
5355	>	fi
5356	>	fi
5357	>	ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
5358	>	if test -n "$ac_ct_CXX"; then
5359	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
5360	>	$as_echo "$ac_ct_CXX" >&6; }
5361	>	else
5362	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5363	>	$as_echo "no" >&6; }
5364	>	fi
5365	>
5366	>
5367	>	test -n "$ac_ct_CXX" && break
5368	>	done
5369	>
5370	>	if test "x$ac_ct_CXX" = x; then
5371	>	CXX="g++"
5372	>	else
5373	>	case $cross_compiling:$ac_tool_warned in
5374	>	yes:)
5375	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5376	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5377	>	ac_tool_warned=yes ;;
5378	>	esac
5379	>	CXX=$ac_ct_CXX
5380	>	fi
5381	>	fi
5382	>
5383	>	fi
5384	>	fi
5385	>	# Provide some information about the compiler.
5386	>	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
5387	>	set X $ac_compile
5388	>	ac_compiler=$2
5389	>	for ac_option in --version -v -V -qversion; do
5390	>	{ { ac_try="$ac_compiler $ac_option >&5"
5391	>	case "(($ac_try" in
5392	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
5393	>	*) ac_try_echo=$ac_try;;
5394	>	esac
5395	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5396	>	$as_echo "$ac_try_echo"; } >&5
5397	>	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
5398	>	ac_status=$?
5399	>	if test -s conftest.err; then
5400	>	sed '10a\
5401	>	... rest of stderr output deleted ...
5402	>	10q' conftest.err >conftest.er1
5403	>	cat conftest.er1 >&5
5404	>	rm -f conftest.er1 conftest.err
5405	>	fi
5406	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
5407	>	test $ac_status = 0; }
5408	>	done
5409	>
5410	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
5411	>	$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
5412	>	if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
5413	>	$as_echo_n "(cached) " >&6
5414	>	else
5415	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5416	>	/* end confdefs.h. */
5417	>
5418	>	int
5419	>	main ()
5420	>	{
5421	>	#ifndef __GNUC__
5422	>	choke me
5423	>	#endif
5424	>
5425	>	;
5426	>	return 0;
5427	>	}
5428	>	_ACEOF
5429	>	if ac_fn_cxx_try_compile "$LINENO"; then :
5430	>	ac_compiler_gnu=yes
5431	>	else
5432	>	ac_compiler_gnu=no
5433	>	fi
5434	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5435	>	ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
5436	>
5437	>	fi
5438	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
5439	>	$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
5440	>	if test $ac_compiler_gnu = yes; then
5441	>	GXX=yes
5442	>	else
5443	>	GXX=
5444	>	fi
5445	>	ac_test_CXXFLAGS=${CXXFLAGS+set}
5446	>	ac_save_CXXFLAGS=$CXXFLAGS
5447	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
5448	>	$as_echo_n "checking whether $CXX accepts -g... " >&6; }
5449	>	if test "${ac_cv_prog_cxx_g+set}" = set; then :
5450	>	$as_echo_n "(cached) " >&6
5451	>	else
5452	>	ac_save_cxx_werror_flag=$ac_cxx_werror_flag
5453	>	ac_cxx_werror_flag=yes
5454	>	ac_cv_prog_cxx_g=no
5455	>	CXXFLAGS="-g"
5456	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5457	>	/* end confdefs.h. */
5458	>
5459	>	int
5460	>	main ()
5461	>	{
5462	>
5463	>	;
5464	>	return 0;
5465	>	}
5466	>	_ACEOF
5467	>	if ac_fn_cxx_try_compile "$LINENO"; then :
5468	>	ac_cv_prog_cxx_g=yes
5469	>	else
5470	>	CXXFLAGS=""
5471	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5472	>	/* end confdefs.h. */
5473	>
5474	>	int
5475	>	main ()
5476	>	{
5477	>
5478	>	;
5479	>	return 0;
5480	>	}
5481	>	_ACEOF
5482	>	if ac_fn_cxx_try_compile "$LINENO"; then :
5483	>
5484	>	else
5485	>	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
5486	>	CXXFLAGS="-g"
5487	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5488	>	/* end confdefs.h. */
5489	>
5490	>	int
5491	>	main ()
5492	>	{
5493	>
5494	>	;
5495	>	return 0;
5496	>	}
5497	>	_ACEOF
5498	>	if ac_fn_cxx_try_compile "$LINENO"; then :
5499	>	ac_cv_prog_cxx_g=yes
5500	>	fi
5501	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5502	>	fi
5503	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5504	>	fi
5505	>	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5506	>	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
5507	>	fi
5508	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
5509	>	$as_echo "$ac_cv_prog_cxx_g" >&6; }
5510	>	if test "$ac_test_CXXFLAGS" = set; then
5511	>	CXXFLAGS=$ac_save_CXXFLAGS
5512	>	elif test $ac_cv_prog_cxx_g = yes; then
5513	>	if test "$GXX" = yes; then
5514	>	CXXFLAGS="-g -O2"
5515	>	else
5516	>	CXXFLAGS="-g"
5517	>	fi
5518	>	else
5519	>	if test "$GXX" = yes; then
5520	>	CXXFLAGS="-O2"
5521	>	else
5522	>	CXXFLAGS=
5523	>	fi
5524	>	fi
5525	>	ac_ext=${ac_fc_srcext-f}
5526	>	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5527	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5528	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5529	>
5530	>	ac_ext=c
5531	>	ac_cpp='$CPP $CPPFLAGS'
5532	>	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5533	>	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5534	>	ac_compiler_gnu=$ac_cv_c_compiler_gnu
5535	>	if test -n "$ac_tool_prefix"; then
5536	>	for ac_prog in $CC icc pathcc pgcc cc xlc gcc
5537	>	do
5538	>	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5539	>	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5540	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5541	>	$as_echo_n "checking for $ac_word... " >&6; }
5542	>	if test "${ac_cv_prog_CC+set}" = set; then :
5543	>	$as_echo_n "(cached) " >&6
5544	>	else
5545	>	if test -n "$CC"; then
5546	>	ac_cv_prog_CC="$CC" # Let the user override the test.
5547	>	else
5548	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5549	>	for as_dir in $PATH
5550	>	do
5551	>	IFS=$as_save_IFS
5552	>	test -z "$as_dir" && as_dir=.
5553	>	for ac_exec_ext in '' $ac_executable_extensions; do
5554	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5555	>	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
5556	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5557	>	break 2
5558	>	fi
5559	>	done
5560	>	done
5561	>	IFS=$as_save_IFS
5562	>
5563	>	fi
5564	>	fi
5565	>	CC=$ac_cv_prog_CC
5566	>	if test -n "$CC"; then
5567	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
5568	>	$as_echo "$CC" >&6; }
5569	>	else
5570	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5571	>	$as_echo "no" >&6; }
5572	>	fi
5573	>
5574	>
5575	>	test -n "$CC" && break
5576	>	done
5577	>	fi
5578	>	if test -z "$CC"; then
5579	>	ac_ct_CC=$CC
5580	>	for ac_prog in $CC icc pathcc pgcc cc xlc gcc
5581	>	do
5582	>	# Extract the first word of "$ac_prog", so it can be a program name with args.
5583	>	set dummy $ac_prog; ac_word=$2
5584	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5585	>	$as_echo_n "checking for $ac_word... " >&6; }
5586	>	if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
5587	>	$as_echo_n "(cached) " >&6
5588	>	else
5589	>	if test -n "$ac_ct_CC"; then
5590	>	ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
5591	>	else
5592	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5593	>	for as_dir in $PATH
5594	>	do
5595	>	IFS=$as_save_IFS
5596	>	test -z "$as_dir" && as_dir=.
5597	>	for ac_exec_ext in '' $ac_executable_extensions; do
5598	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5599	>	ac_cv_prog_ac_ct_CC="$ac_prog"
5600	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5601	>	break 2
5602	>	fi
5603	>	done
5604	>	done
5605	>	IFS=$as_save_IFS
5606	>
5607	>	fi
5608	>	fi
5609	>	ac_ct_CC=$ac_cv_prog_ac_ct_CC
5610	>	if test -n "$ac_ct_CC"; then
5611	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
5612	>	$as_echo "$ac_ct_CC" >&6; }
5613	>	else
5614	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5615	>	$as_echo "no" >&6; }
5616	>	fi
5617	>
5618	>
5619	>	test -n "$ac_ct_CC" && break
5620	>	done
5621	>
5622	>	if test "x$ac_ct_CC" = x; then
5623	>	CC=""
5624	>	else
5625	>	case $cross_compiling:$ac_tool_warned in
5626	>	yes:)
5627	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5628	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5629	>	ac_tool_warned=yes ;;
5630	>	esac
5631	>	CC=$ac_ct_CC
5632	>	fi
5633	>	fi
5634	>
5635	>
5636	>	test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
5637	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5638	>	as_fn_error "no acceptable C compiler found in \$PATH
5639	>	See \`config.log' for more details." "$LINENO" 5; }
5640	>
5641	>	# Provide some information about the compiler.
5642	>	$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
5643	>	set X $ac_compile
5644	>	ac_compiler=$2
5645	>	for ac_option in --version -v -V -qversion; do
5646	>	{ { ac_try="$ac_compiler $ac_option >&5"
5647	>	case "(($ac_try" in
5648	>	\" \| \` \| \\) ac_try_echo=\$ac_try;;
5649	>	*) ac_try_echo=$ac_try;;
5650	>	esac
5651	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5652	>	$as_echo "$ac_try_echo"; } >&5
5653	>	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
5654	>	ac_status=$?
5655	>	if test -s conftest.err; then
5656	>	sed '10a\
5657	>	... rest of stderr output deleted ...
5658	>	10q' conftest.err >conftest.er1
5659	>	cat conftest.er1 >&5
5660	>	rm -f conftest.er1 conftest.err
5661	>	fi
5662	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
5663	>	test $ac_status = 0; }
5664	>	done
5665	>
5666	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
5667	>	$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
5668	>	if test "${ac_cv_c_compiler_gnu+set}" = set; then :
5669	>	$as_echo_n "(cached) " >&6
5670	>	else
5671	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5672	>	/* end confdefs.h. */
5673	>
5674	>	int
5675	>	main ()
5676	>	{
5677	>	#ifndef __GNUC__
5678	>	choke me
5679		#endif
5680	+
5681	+	;
5682	+	return 0;
5683	+	}
5684	+	_ACEOF
5685	+	if ac_fn_c_try_compile "$LINENO"; then :
5686	+	ac_compiler_gnu=yes
5687	+	else
5688	+	ac_compiler_gnu=no
5689	+	fi
5690	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5691	+	ac_cv_c_compiler_gnu=$ac_compiler_gnu
5692	+
5693	+	fi
5694	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
5695	+	$as_echo "$ac_cv_c_compiler_gnu" >&6; }
5696	+	if test $ac_compiler_gnu = yes; then
5697	+	GCC=yes
5698	+	else
5699	+	GCC=
5700	+	fi
5701	+	ac_test_CFLAGS=${CFLAGS+set}
5702	+	ac_save_CFLAGS=$CFLAGS
5703	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
5704	+	$as_echo_n "checking whether $CC accepts -g... " >&6; }
5705	+	if test "${ac_cv_prog_cc_g+set}" = set; then :
5706	+	$as_echo_n "(cached) " >&6
5707	+	else
5708	+	ac_save_c_werror_flag=$ac_c_werror_flag
5709	+	ac_c_werror_flag=yes
5710	+	ac_cv_prog_cc_g=no
5711	+	CFLAGS="-g"
5712	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5713	+	/* end confdefs.h. */
5714	+
5715	+	int
5716	+	main ()
5717	+	{
5718	+
5719	+	;
5720	+	return 0;
5721	+	}
5722	+	_ACEOF
5723	+	if ac_fn_c_try_compile "$LINENO"; then :
5724	+	ac_cv_prog_cc_g=yes
5725	+	else
5726	+	CFLAGS=""
5727	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5728	+	/* end confdefs.h. */
5729	+
5730	+	int
5731	+	main ()
5732	+	{
5733	+
5734	+	;
5735	+	return 0;
5736	+	}
5737	+	_ACEOF
5738	+	if ac_fn_c_try_compile "$LINENO"; then :
5739	+
5740	+	else
5741	+	ac_c_werror_flag=$ac_save_c_werror_flag
5742	+	CFLAGS="-g"
5743	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5744	+	/* end confdefs.h. */
5745	+
5746	+	int
5747	+	main ()
5748	+	{
5749	+
5750	+	;
5751	+	return 0;
5752	+	}
5753	+	_ACEOF
5754	+	if ac_fn_c_try_compile "$LINENO"; then :
5755	+	ac_cv_prog_cc_g=yes
5756	+	fi
5757	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5758	+	fi
5759	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5760	+	fi
5761	+	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5762	+	ac_c_werror_flag=$ac_save_c_werror_flag
5763	+	fi
5764	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
5765	+	$as_echo "$ac_cv_prog_cc_g" >&6; }
5766	+	if test "$ac_test_CFLAGS" = set; then
5767	+	CFLAGS=$ac_save_CFLAGS
5768	+	elif test $ac_cv_prog_cc_g = yes; then
5769	+	if test "$GCC" = yes; then
5770	+	CFLAGS="-g -O2"
5771	+	else
5772	+	CFLAGS="-g"
5773	+	fi
5774	+	else
5775	+	if test "$GCC" = yes; then
5776	+	CFLAGS="-O2"
5777	+	else
5778	+	CFLAGS=
5779	+	fi
5780	+	fi
5781	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
5782	+	$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
5783	+	if test "${ac_cv_prog_cc_c89+set}" = set; then :
5784	+	$as_echo_n "(cached) " >&6
5785	+	else
5786	+	ac_cv_prog_cc_c89=no
5787	+	ac_save_CC=$CC
5788	+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5789	+	/* end confdefs.h. */
5790	+	#include <stdarg.h>
5791	+	#include <stdio.h>
5792	+	#include <sys/types.h>
5793	+	#include <sys/stat.h>
5794	+	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
5795	+	struct buf { int x; };
5796	+	FILE * (rcsopen) (struct buf , struct stat *, int);
5797	+	static char *e (p, i)
5798	+	char **p;
5799	+	int i;
5800	+	{
5801	+	return p[i];
5802	+	}
5803	+	static char f (char (g) (char , int), char *p, ...)
5804	+	{
5805	+	char *s;
5806	+	va_list v;
5807	+	va_start (v,p);
5808	+	s = g (p, va_arg (v,int));
5809	+	va_end (v);
5810	+	return s;
5811	+	}
5812	+
5813	+	/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
5814	+	function prototypes and stuff, but not '\xHH' hex character constants.
5815	+	These don't provoke an error unfortunately, instead are silently treated
5816	+	as 'x'. The following induces an error, until -std is added to get
5817	+	proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
5818	+	array size at least. It's necessary to write '\x00'==0 to get something
5819	+	that's true only with -std. */
5820	+	int osf4_cc_array ['\x00' == 0 ? 1 : -1];
5821	+
5822	+	/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
5823	+	inside strings and character constants. */
5824	+	#define FOO(x) 'x'
5825	+	int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
5826	+
5827	+	int test (int i, double x);
5828	+	struct s1 {int (*f) (int a);};
5829	+	struct s2 {int (*f) (double a);};
5830	+	int pairnames (int, char *, FILE ()(struct buf , struct stat *, int), int, int);
5831	+	int argc;
5832	+	char **argv;
5833	+	int
5834	+	main ()
5835	+	{
5836	+	return f (e, argv, 0) != argv[0] \|\| f (e, argv, 1) != argv[1];
5837	+	;
5838	+	return 0;
5839	+	}
5840	+	_ACEOF
5841	+	for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
5842	+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
5843	+	do
5844	+	CC="$ac_save_CC $ac_arg"
5845	+	if ac_fn_c_try_compile "$LINENO"; then :
5846	+	ac_cv_prog_cc_c89=$ac_arg
5847	+	fi
5848	+	rm -f core conftest.err conftest.$ac_objext
5849	+	test "x$ac_cv_prog_cc_c89" != "xno" && break
5850	+	done
5851	+	rm -f conftest.$ac_ext
5852	+	CC=$ac_save_CC
5853	+
5854	+	fi
5855	+	# AC_CACHE_VAL
5856	+	case "x$ac_cv_prog_cc_c89" in
5857	+	x)
5858	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
5859	+	$as_echo "none needed" >&6; } ;;
5860	+	xno)
5861	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
5862	+	$as_echo "unsupported" >&6; } ;;
5863	+	*)
5864	+	CC="$CC $ac_cv_prog_cc_c89"
5865	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
5866	+	$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
5867	+	esac
5868	+	if test "x$ac_cv_prog_cc_c89" != xno; then :
5869	+
5870	+	fi
5871	+
5872	+	ac_ext=${ac_fc_srcext-f}
5873	+	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5874	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5875	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5876	+
5877	+	ac_ext=${ac_fc_srcext-f}
5878	+	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5879	+	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5880	+	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5881	+	if test -n "$ac_tool_prefix"; then
5882	+	for ac_prog in $FC ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
5883	+	do
5884	+	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5885	+	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5886	+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5887	+	$as_echo_n "checking for $ac_word... " >&6; }
5888	+	if test "${ac_cv_prog_FC+set}" = set; then :
5889	+	$as_echo_n "(cached) " >&6
5890	+	else
5891	+	if test -n "$FC"; then
5892	+	ac_cv_prog_FC="$FC" # Let the user override the test.
5893	+	else
5894	+	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5895	+	for as_dir in $PATH
5896	+	do
5897	+	IFS=$as_save_IFS
5898	+	test -z "$as_dir" && as_dir=.
5899	+	for ac_exec_ext in '' $ac_executable_extensions; do
5900	+	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5901	+	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
5902	+	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5903	+	break 2
5904	+	fi
5905	+	done
5906	+	done
5907	+	IFS=$as_save_IFS
5908
5909	<	end
5910	<	_ACEOF
5911	<	rm -f conftest.$ac_objext
5912	<	if { (ac_try="$ac_compile"
5909	>	fi
5910	>	fi
5911	>	FC=$ac_cv_prog_FC
5912	>	if test -n "$FC"; then
5913	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
5914	>	$as_echo "$FC" >&6; }
5915	>	else
5916	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5917	>	$as_echo "no" >&6; }
5918	>	fi
5919	>
5920	>
5921	>	test -n "$FC" && break
5922	>	done
5923	>	fi
5924	>	if test -z "$FC"; then
5925	>	ac_ct_FC=$FC
5926	>	for ac_prog in $FC ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
5927	>	do
5928	>	# Extract the first word of "$ac_prog", so it can be a program name with args.
5929	>	set dummy $ac_prog; ac_word=$2
5930	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5931	>	$as_echo_n "checking for $ac_word... " >&6; }
5932	>	if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
5933	>	$as_echo_n "(cached) " >&6
5934	>	else
5935	>	if test -n "$ac_ct_FC"; then
5936	>	ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
5937	>	else
5938	>	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5939	>	for as_dir in $PATH
5940	>	do
5941	>	IFS=$as_save_IFS
5942	>	test -z "$as_dir" && as_dir=.
5943	>	for ac_exec_ext in '' $ac_executable_extensions; do
5944	>	if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5945	>	ac_cv_prog_ac_ct_FC="$ac_prog"
5946	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5947	>	break 2
5948	>	fi
5949	>	done
5950	>	done
5951	>	IFS=$as_save_IFS
5952	>
5953	>	fi
5954	>	fi
5955	>	ac_ct_FC=$ac_cv_prog_ac_ct_FC
5956	>	if test -n "$ac_ct_FC"; then
5957	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
5958	>	$as_echo "$ac_ct_FC" >&6; }
5959	>	else
5960	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5961	>	$as_echo "no" >&6; }
5962	>	fi
5963	>
5964	>
5965	>	test -n "$ac_ct_FC" && break
5966	>	done
5967	>
5968	>	if test "x$ac_ct_FC" = x; then
5969	>	FC=""
5970	>	else
5971	>	case $cross_compiling:$ac_tool_warned in
5972	>	yes:)
5973	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5974	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5975	>	ac_tool_warned=yes ;;
5976	>	esac
5977	>	FC=$ac_ct_FC
5978	>	fi
5979	>	fi
5980	>
5981	>
5982	>	# Provide some information about the compiler.
5983	>	$as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
5984	>	set X $ac_compile
5985	>	ac_compiler=$2
5986	>	for ac_option in --version -v -V -qversion; do
5987	>	{ { ac_try="$ac_compiler $ac_option >&5"
5988		case "(($ac_try" in
5989		\" \| \` \| \\) ac_try_echo=\$ac_try;;
5990		*) ac_try_echo=$ac_try;;
5991		esac
5992	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5993	<	$as_echo "$ac_try_echo") >&5
5994	<	(eval "$ac_compile") 2>conftest.er1
5992	>	eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5993	>	$as_echo "$ac_try_echo"; } >&5
5994	>	(eval "$ac_compiler $ac_option >&5") 2>conftest.err
5995		ac_status=$?
5996	<	grep -v '^ *+' conftest.er1 >conftest.err
5997	<	rm -f conftest.er1
5998	<	cat conftest.err >&5
5999	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6000	<	(exit $ac_status); } && {
6001	<	test -z "$ac_fc_werror_flag" \|\|
6002	<	test ! -s conftest.err
6003	<	} && test -s conftest.$ac_objext; then
6004	<	ac_compiler_gnu=yes
5996	>	if test -s conftest.err; then
5997	>	sed '10a\
5998	>	... rest of stderr output deleted ...
5999	>	10q' conftest.err >conftest.er1
6000	>	cat conftest.er1 >&5
6001	>	rm -f conftest.er1 conftest.err
6002	>	fi
6003	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6004	>	test $ac_status = 0; }
6005	>	done
6006	>	rm -f a.out
6007	>
6008	>	# If we don't use `.F' as extension, the preprocessor is not run on the
6009	>	# input file. (Note that this only needs to work for GNU compilers.)
6010	>	ac_save_ext=$ac_ext
6011	>	ac_ext=F
6012	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
6013	>	$as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
6014	>	if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
6015	>	$as_echo_n "(cached) " >&6
6016		else
6017	<	$as_echo "$as_me: failed program was:" >&5
6018	<	sed 's/^/\| /' conftest.$ac_ext >&5
6017	>	cat > conftest.$ac_ext <<_ACEOF
6018	>	program main
6019	>	#ifndef __GNUC__
6020	>	choke me
6021	>	#endif
6022
6023	<	ac_compiler_gnu=no
6023	>	end
6024	>	_ACEOF
6025	>	if ac_fn_fc_try_compile "$LINENO"; then :
6026	>	ac_compiler_gnu=yes
6027	>	else
6028	>	ac_compiler_gnu=no
6029		fi
4662	–
6030		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6031		ac_cv_fc_compiler_gnu=$ac_compiler_gnu
6032
6033		fi
6034	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
6034	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
6035		$as_echo "$ac_cv_fc_compiler_gnu" >&6; }
6036		ac_ext=$ac_save_ext
6037	<	ac_test_FFLAGS=${FCFLAGS+set}
6038	<	ac_save_FFLAGS=$FCFLAGS
6037	>	ac_test_FCFLAGS=${FCFLAGS+set}
6038	>	ac_save_FCFLAGS=$FCFLAGS
6039		FCFLAGS=
6040	<	{ $as_echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
6040	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
6041		$as_echo_n "checking whether $FC accepts -g... " >&6; }
6042	<	if test "${ac_cv_prog_fc_g+set}" = set; then
6042	>	if test "${ac_cv_prog_fc_g+set}" = set; then :
6043		$as_echo_n "(cached) " >&6
6044		else
6045		FCFLAGS=-g
6046	<	cat >conftest.$ac_ext <<_ACEOF
6046	>	cat > conftest.$ac_ext <<_ACEOF
6047		program main
6048
6049		end
6050		_ACEOF
6051	<	rm -f conftest.$ac_objext
4685	<	if { (ac_try="$ac_compile"
4686	<	case "(($ac_try" in
4687	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4688	<	*) ac_try_echo=$ac_try;;
4689	<	esac
4690	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4691	<	$as_echo "$ac_try_echo") >&5
4692	<	(eval "$ac_compile") 2>conftest.er1
4693	<	ac_status=$?
4694	<	grep -v '^ *+' conftest.er1 >conftest.err
4695	<	rm -f conftest.er1
4696	<	cat conftest.err >&5
4697	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4698	<	(exit $ac_status); } && {
4699	<	test -z "$ac_fc_werror_flag" \|\|
4700	<	test ! -s conftest.err
4701	<	} && test -s conftest.$ac_objext; then
6051	>	if ac_fn_fc_try_compile "$LINENO"; then :
6052		ac_cv_prog_fc_g=yes
6053		else
6054	<	$as_echo "$as_me: failed program was:" >&5
4705	<	sed 's/^/\| /' conftest.$ac_ext >&5
4706	<
4707	<	ac_cv_prog_fc_g=no
6054	>	ac_cv_prog_fc_g=no
6055		fi
4709	–
6056		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6057
6058		fi
6059	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
6059	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
6060		$as_echo "$ac_cv_prog_fc_g" >&6; }
6061	<	if test "$ac_test_FFLAGS" = set; then
6062	<	FCFLAGS=$ac_save_FFLAGS
6061	>	if test "$ac_test_FCFLAGS" = set; then
6062	>	FCFLAGS=$ac_save_FCFLAGS
6063		elif test $ac_cv_prog_fc_g = yes; then
6064		if test "x$ac_cv_fc_compiler_gnu" = xyes; then
6065		FCFLAGS="-g -O2"
#	Line 4728 \| Line 6074 \| fi
6074		fi
6075		fi
6076
6077	<	ac_ext=c
6078	<	ac_cpp='$CPP $CPPFLAGS'
6079	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6080	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4735	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6077	>	ac_ext=${ac_fc_srcext-f}
6078	>	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6079	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6080	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6081
6082		ac_ext=c
6083		ac_cpp='$CPP $CPPFLAGS'
6084		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6085		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6086		ac_compiler_gnu=$ac_cv_c_compiler_gnu
6087	<	{ $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
6087	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
6088		$as_echo_n "checking how to run the C preprocessor... " >&6; }
6089		# On Suns, sometimes $CPP names a directory.
6090		if test -n "$CPP" && test -d "$CPP"; then
6091		CPP=
6092		fi
6093		if test -z "$CPP"; then
6094	<	if test "${ac_cv_prog_CPP+set}" = set; then
6094	>	if test "${ac_cv_prog_CPP+set}" = set; then :
6095		$as_echo_n "(cached) " >&6
6096		else
6097		# Double quotes because CPP needs to be expanded
#	Line 4761 \| Line 6106 \| do
6106		# <limits.h> exists even on freestanding compilers.
6107		# On the NeXT, cc -E runs the code through the compiler's parser,
6108		# not just through cpp. "Syntax error" is here to catch this case.
6109	<	cat >conftest.$ac_ext <<_ACEOF
4765	<	/* confdefs.h. */
4766	<	_ACEOF
4767	<	cat confdefs.h >>conftest.$ac_ext
4768	<	cat >>conftest.$ac_ext <<_ACEOF
6109	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6110		/* end confdefs.h. */
6111		#ifdef __STDC__
6112		# include <limits.h>
#	Line 4774 \| Line 6115 \| _ACEOF
6115		#endif
6116		Syntax error
6117		_ACEOF
6118	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
4778	<	case "(($ac_try" in
4779	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4780	<	*) ac_try_echo=$ac_try;;
4781	<	esac
4782	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4783	<	$as_echo "$ac_try_echo") >&5
4784	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4785	<	ac_status=$?
4786	<	grep -v '^ *+' conftest.er1 >conftest.err
4787	<	rm -f conftest.er1
4788	<	cat conftest.err >&5
4789	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4790	<	(exit $ac_status); } >/dev/null && {
4791	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
4792	<	test ! -s conftest.err
4793	<	}; then
4794	<	:
4795	<	else
4796	<	$as_echo "$as_me: failed program was:" >&5
4797	<	sed 's/^/\| /' conftest.$ac_ext >&5
6118	>	if ac_fn_c_try_cpp "$LINENO"; then :
6119
6120	+	else
6121		# Broken: fails on valid input.
6122		continue
6123		fi
4802	–
6124		rm -f conftest.err conftest.$ac_ext
6125
6126		# OK, works on sane cases. Now check whether nonexistent headers
6127		# can be detected and how.
6128	<	cat >conftest.$ac_ext <<_ACEOF
4808	<	/* confdefs.h. */
4809	<	_ACEOF
4810	<	cat confdefs.h >>conftest.$ac_ext
4811	<	cat >>conftest.$ac_ext <<_ACEOF
6128	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6129		/* end confdefs.h. */
6130		#include <ac_nonexistent.h>
6131		_ACEOF
6132	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
4816	<	case "(($ac_try" in
4817	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4818	<	*) ac_try_echo=$ac_try;;
4819	<	esac
4820	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4821	<	$as_echo "$ac_try_echo") >&5
4822	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4823	<	ac_status=$?
4824	<	grep -v '^ *+' conftest.er1 >conftest.err
4825	<	rm -f conftest.er1
4826	<	cat conftest.err >&5
4827	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828	<	(exit $ac_status); } >/dev/null && {
4829	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
4830	<	test ! -s conftest.err
4831	<	}; then
6132	>	if ac_fn_c_try_cpp "$LINENO"; then :
6133		# Broken: success on invalid input.
6134		continue
6135		else
4835	–	$as_echo "$as_me: failed program was:" >&5
4836	–	sed 's/^/\| /' conftest.$ac_ext >&5
4837	–
6136		# Passes both tests.
6137		ac_preproc_ok=:
6138		break
6139		fi
4842	–
6140		rm -f conftest.err conftest.$ac_ext
6141
6142		done
6143		# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
6144		rm -f conftest.err conftest.$ac_ext
6145	<	if $ac_preproc_ok; then
6145	>	if $ac_preproc_ok; then :
6146		break
6147		fi
6148
#	Line 4857 \| Line 6154 \| fi
6154		else
6155		ac_cv_prog_CPP=$CPP
6156		fi
6157	<	{ $as_echo "$as_me:$LINENO: result: $CPP" >&5
6157	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
6158		$as_echo "$CPP" >&6; }
6159		ac_preproc_ok=false
6160		for ac_c_preproc_warn_flag in '' yes
#	Line 4868 \| Line 6165 \| do
6165		# <limits.h> exists even on freestanding compilers.
6166		# On the NeXT, cc -E runs the code through the compiler's parser,
6167		# not just through cpp. "Syntax error" is here to catch this case.
6168	<	cat >conftest.$ac_ext <<_ACEOF
4872	<	/* confdefs.h. */
4873	<	_ACEOF
4874	<	cat confdefs.h >>conftest.$ac_ext
4875	<	cat >>conftest.$ac_ext <<_ACEOF
6168	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6169		/* end confdefs.h. */
6170		#ifdef __STDC__
6171		# include <limits.h>
#	Line 4881 \| Line 6174 \| _ACEOF
6174		#endif
6175		Syntax error
6176		_ACEOF
6177	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
4885	<	case "(($ac_try" in
4886	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4887	<	*) ac_try_echo=$ac_try;;
4888	<	esac
4889	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4890	<	$as_echo "$ac_try_echo") >&5
4891	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4892	<	ac_status=$?
4893	<	grep -v '^ *+' conftest.er1 >conftest.err
4894	<	rm -f conftest.er1
4895	<	cat conftest.err >&5
4896	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4897	<	(exit $ac_status); } >/dev/null && {
4898	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
4899	<	test ! -s conftest.err
4900	<	}; then
4901	<	:
4902	<	else
4903	<	$as_echo "$as_me: failed program was:" >&5
4904	<	sed 's/^/\| /' conftest.$ac_ext >&5
6177	>	if ac_fn_c_try_cpp "$LINENO"; then :
6178
6179	+	else
6180		# Broken: fails on valid input.
6181		continue
6182		fi
4909	–
6183		rm -f conftest.err conftest.$ac_ext
6184
6185		# OK, works on sane cases. Now check whether nonexistent headers
6186		# can be detected and how.
6187	<	cat >conftest.$ac_ext <<_ACEOF
4915	<	/* confdefs.h. */
4916	<	_ACEOF
4917	<	cat confdefs.h >>conftest.$ac_ext
4918	<	cat >>conftest.$ac_ext <<_ACEOF
6187	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6188		/* end confdefs.h. */
6189		#include <ac_nonexistent.h>
6190		_ACEOF
6191	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
4923	<	case "(($ac_try" in
4924	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
4925	<	*) ac_try_echo=$ac_try;;
4926	<	esac
4927	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4928	<	$as_echo "$ac_try_echo") >&5
4929	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4930	<	ac_status=$?
4931	<	grep -v '^ *+' conftest.er1 >conftest.err
4932	<	rm -f conftest.er1
4933	<	cat conftest.err >&5
4934	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4935	<	(exit $ac_status); } >/dev/null && {
4936	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
4937	<	test ! -s conftest.err
4938	<	}; then
6191	>	if ac_fn_c_try_cpp "$LINENO"; then :
6192		# Broken: success on invalid input.
6193		continue
6194		else
4942	–	$as_echo "$as_me: failed program was:" >&5
4943	–	sed 's/^/\| /' conftest.$ac_ext >&5
4944	–
6195		# Passes both tests.
6196		ac_preproc_ok=:
6197		break
6198		fi
4949	–
6199		rm -f conftest.err conftest.$ac_ext
6200
6201		done
6202		# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
6203		rm -f conftest.err conftest.$ac_ext
6204	<	if $ac_preproc_ok; then
6205	<	:
6204	>	if $ac_preproc_ok; then :
6205	>
6206		else
6207	<	{ { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
6208	<	See \`config.log' for more details." >&5
6209	<	$as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
6210	<	See \`config.log' for more details." >&2;}
4962	<	{ (exit 1); exit 1; }; }
6207	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
6208	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
6209	>	as_fn_error "C preprocessor \"$CPP\" fails sanity check
6210	>	See \`config.log' for more details." "$LINENO" 5; }
6211		fi
6212
6213	<	ac_ext=c
6214	<	ac_cpp='$CPP $CPPFLAGS'
6215	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6216	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4969	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
6213	>	ac_ext=${ac_fc_srcext-f}
6214	>	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6215	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6216	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6217
6218	<	{ $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
6218	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
6219		$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
6220	<	if test "${ac_cv_path_GREP+set}" = set; then
6220	>	if test "${ac_cv_path_GREP+set}" = set; then :
6221		$as_echo_n "(cached) " >&6
6222		else
6223		if test -z "$GREP"; then
#	Line 4981 \| Line 6228 \| do
6228		do
6229		IFS=$as_save_IFS
6230		test -z "$as_dir" && as_dir=.
6231	<	for ac_prog in grep ggrep; do
6231	>	for ac_prog in grep ggrep; do
6232		for ac_exec_ext in '' $ac_executable_extensions; do
6233		ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
6234		{ test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } \|\| continue
#	Line 5001 \| Line 6248 \| case `"$ac_path_GREP" --version 2>&1` in
6248		$as_echo 'GREP' >> "conftest.nl"
6249		"$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null \|\| break
6250		diff "conftest.out" "conftest.nl" >/dev/null 2>&1 \|\| break
6251	<	ac_count=`expr $ac_count + 1`
6251	>	as_fn_arith $ac_count + 1 && ac_count=$as_val
6252		if test $ac_count -gt ${ac_path_GREP_max-0}; then
6253		# Best one so far, save it but keep looking for a better one
6254		ac_cv_path_GREP="$ac_path_GREP"
#	Line 5016 \| Line 6263 \| esac
6263		$ac_path_GREP_found && break 3
6264		done
6265		done
6266	<	done
6266	>	done
6267		IFS=$as_save_IFS
6268		if test -z "$ac_cv_path_GREP"; then
6269	<	{ { $as_echo "$as_me:$LINENO: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5023	<	$as_echo "$as_me: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5024	<	{ (exit 1); exit 1; }; }
6269	>	as_fn_error "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
6270		fi
6271		else
6272		ac_cv_path_GREP=$GREP
6273		fi
6274
6275		fi
6276	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
6276	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
6277		$as_echo "$ac_cv_path_GREP" >&6; }
6278		GREP="$ac_cv_path_GREP"
6279
6280
6281	<	{ $as_echo "$as_me:$LINENO: checking for egrep" >&5
6281	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
6282		$as_echo_n "checking for egrep... " >&6; }
6283	<	if test "${ac_cv_path_EGREP+set}" = set; then
6283	>	if test "${ac_cv_path_EGREP+set}" = set; then :
6284		$as_echo_n "(cached) " >&6
6285		else
6286		if echo a \| $GREP -E '(a\|b)' >/dev/null 2>&1
#	Line 5049 \| Line 6294 \| do
6294		do
6295		IFS=$as_save_IFS
6296		test -z "$as_dir" && as_dir=.
6297	<	for ac_prog in egrep; do
6297	>	for ac_prog in egrep; do
6298		for ac_exec_ext in '' $ac_executable_extensions; do
6299		ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
6300		{ test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } \|\| continue
#	Line 5069 \| Line 6314 \| case `"$ac_path_EGREP" --version 2>&1` in
6314		$as_echo 'EGREP' >> "conftest.nl"
6315		"$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null \|\| break
6316		diff "conftest.out" "conftest.nl" >/dev/null 2>&1 \|\| break
6317	<	ac_count=`expr $ac_count + 1`
6317	>	as_fn_arith $ac_count + 1 && ac_count=$as_val
6318		if test $ac_count -gt ${ac_path_EGREP_max-0}; then
6319		# Best one so far, save it but keep looking for a better one
6320		ac_cv_path_EGREP="$ac_path_EGREP"
#	Line 5084 \| Line 6329 \| esac
6329		$ac_path_EGREP_found && break 3
6330		done
6331		done
6332	<	done
6332	>	done
6333		IFS=$as_save_IFS
6334		if test -z "$ac_cv_path_EGREP"; then
6335	<	{ { $as_echo "$as_me:$LINENO: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5091	<	$as_echo "$as_me: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5092	<	{ (exit 1); exit 1; }; }
6335	>	as_fn_error "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
6336		fi
6337		else
6338		ac_cv_path_EGREP=$EGREP
#	Line 5097 \| Line 6340 \| fi
6340
6341		fi
6342		fi
6343	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
6343	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
6344		$as_echo "$ac_cv_path_EGREP" >&6; }
6345		EGREP="$ac_cv_path_EGREP"
6346
6347
6348	<	{ $as_echo "$as_me:$LINENO: checking whether ln -s works" >&5
6348	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
6349		$as_echo_n "checking whether ln -s works... " >&6; }
6350		LN_S=$as_ln_s
6351		if test "$LN_S" = "ln -s"; then
6352	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
6352	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
6353		$as_echo "yes" >&6; }
6354		else
6355	<	{ $as_echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6355	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
6356		$as_echo "no, using $LN_S" >&6; }
6357		fi
6358
6359	<	{ $as_echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6359	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6360		$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
6361		set x ${MAKE-make}
6362		ac_make=`$as_echo "$2" \| sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
6363	<	if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
6363	>	if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then :
6364		$as_echo_n "(cached) " >&6
6365		else
6366		cat >conftest.make <<\_ACEOF
#	Line 5135 \| Line 6378 \| if eval test \$ac_cv_prog_make_${ac_make}_set = yes; t
6378		rm -f conftest.make
6379		fi
6380		if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
6381	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
6381	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
6382		$as_echo "yes" >&6; }
6383		SET_MAKE=
6384		else
6385	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
6385	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6386		$as_echo "no" >&6; }
6387		SET_MAKE="MAKE=${MAKE-make}"
6388		fi
#	Line 5147 \| Line 6390 \| set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6390		if test -n "$ac_tool_prefix"; then
6391		# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6392		set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6393	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
6393	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6394		$as_echo_n "checking for $ac_word... " >&6; }
6395	<	if test "${ac_cv_prog_RANLIB+set}" = set; then
6395	>	if test "${ac_cv_prog_RANLIB+set}" = set; then :
6396		$as_echo_n "(cached) " >&6
6397		else
6398		if test -n "$RANLIB"; then
#	Line 5160 \| Line 6403 \| do
6403		do
6404		IFS=$as_save_IFS
6405		test -z "$as_dir" && as_dir=.
6406	<	for ac_exec_ext in '' $ac_executable_extensions; do
6406	>	for ac_exec_ext in '' $ac_executable_extensions; do
6407		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6408		ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6409	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6409	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6410		break 2
6411		fi
6412		done
6413	<	done
6413	>	done
6414		IFS=$as_save_IFS
6415
6416		fi
6417		fi
6418		RANLIB=$ac_cv_prog_RANLIB
6419		if test -n "$RANLIB"; then
6420	<	{ $as_echo "$as_me:$LINENO: result: $RANLIB" >&5
6420	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
6421		$as_echo "$RANLIB" >&6; }
6422		else
6423	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
6423	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6424		$as_echo "no" >&6; }
6425		fi
6426
#	Line 5187 \| Line 6430 \| set dummy ranlib; ac_word=$2
6430		ac_ct_RANLIB=$RANLIB
6431		# Extract the first word of "ranlib", so it can be a program name with args.
6432		set dummy ranlib; ac_word=$2
6433	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
6433	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6434		$as_echo_n "checking for $ac_word... " >&6; }
6435	<	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6435	>	if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then :
6436		$as_echo_n "(cached) " >&6
6437		else
6438		if test -n "$ac_ct_RANLIB"; then
#	Line 5200 \| Line 6443 \| do
6443		do
6444		IFS=$as_save_IFS
6445		test -z "$as_dir" && as_dir=.
6446	<	for ac_exec_ext in '' $ac_executable_extensions; do
6446	>	for ac_exec_ext in '' $ac_executable_extensions; do
6447		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6448		ac_cv_prog_ac_ct_RANLIB="ranlib"
6449	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6449	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6450		break 2
6451		fi
6452		done
6453	<	done
6453	>	done
6454		IFS=$as_save_IFS
6455
6456		fi
6457		fi
6458		ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6459		if test -n "$ac_ct_RANLIB"; then
6460	<	{ $as_echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6460	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
6461		$as_echo "$ac_ct_RANLIB" >&6; }
6462		else
6463	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
6463	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6464		$as_echo "no" >&6; }
6465		fi
6466
#	Line 5226 \| Line 6469 \| yes:)
6469		else
6470		case $cross_compiling:$ac_tool_warned in
6471		yes:)
6472	<	{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
6473	<	whose name does not start with the host triplet. If you think this
5231	<	configuration is useful to you, please write to autoconf@gnu.org." >&5
5232	<	$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
5233	<	whose name does not start with the host triplet. If you think this
5234	<	configuration is useful to you, please write to autoconf@gnu.org." >&2;}
6472	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
6473	>	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
6474		ac_tool_warned=yes ;;
6475		esac
6476		RANLIB=$ac_ct_RANLIB
#	Line 5243 \| Line 6482 \| set dummy perl; ac_word=$2
6482
6483		# Extract the first word of "perl", so it can be a program name with args.
6484		set dummy perl; ac_word=$2
6485	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
6485	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6486		$as_echo_n "checking for $ac_word... " >&6; }
6487	<	if test "${ac_cv_path_PERLINTERP+set}" = set; then
6487	>	if test "${ac_cv_path_PERLINTERP+set}" = set; then :
6488		$as_echo_n "(cached) " >&6
6489		else
6490		case $PERLINTERP in
#	Line 5258 \| Line 6497 \| do
6497		do
6498		IFS=$as_save_IFS
6499		test -z "$as_dir" && as_dir=.
6500	<	for ac_exec_ext in '' $ac_executable_extensions; do
6500	>	for ac_exec_ext in '' $ac_executable_extensions; do
6501		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6502		ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
6503	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6503	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6504		break 2
6505		fi
6506		done
6507	<	done
6507	>	done
6508		IFS=$as_save_IFS
6509
6510		test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
#	Line 5274 \| Line 6513 \| if test -n "$PERLINTERP"; then
6513		fi
6514		PERLINTERP=$ac_cv_path_PERLINTERP
6515		if test -n "$PERLINTERP"; then
6516	<	{ $as_echo "$as_me:$LINENO: result: $PERLINTERP" >&5
6516	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERLINTERP" >&5
6517		$as_echo "$PERLINTERP" >&6; }
6518		else
6519	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
6519	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6520		$as_echo "no" >&6; }
6521		fi
6522
#	Line 5287 \| Line 6526 \| fi
6526
6527
6528		# Check whether --with-perl-shebang was given.
6529	<	if test "${with_perl_shebang+set}" = set; then
6529	>	if test "${with_perl_shebang+set}" = set; then :
6530		withval=$with_perl_shebang; opt_perl_shebang="$withval"
6531		else
6532		opt_perl_shebang="not_set"
6533		fi
6534
6535	<	{ $as_echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
6535	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether explicit instead of detected sharpbang is to be used" >&5
6536		$as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
6537	<	if test "${ax_cv_opt_perl_shebang+set}" = set; then
6537	>	if test "${ax_cv_opt_perl_shebang+set}" = set; then :
6538		$as_echo_n "(cached) " >&6
6539		else
6540		case "$opt_perl_shebang" in
#	Line 5306 \| Line 6545 \| fi
6545		esac
6546
6547		fi
6548	<	{ $as_echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
6548	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_opt_perl_shebang" >&5
6549		$as_echo "$ax_cv_opt_perl_shebang" >&6; }
6550		if test "A$ax_cv_opt_perl_shebang" != "A"
6551		then
6552		ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
6553		PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
6554	<	{ $as_echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
6554	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
6555		$as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
6556
6557		# Automatic detection of sharpbang formula starts here
6558		else
6559		_somian_shbangperl=`$PERLINTERP -V:startperl`
6560		negclass="[^']"; # must leave this comment: m4 will remove the outer brackets for us, heheh
6561	<	{ $as_echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
6561	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for kernel sharpbang invocation to start perl" >&5
6562		$as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
6563	<	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
6563	>	if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then :
6564		$as_echo_n "(cached) " >&6
6565		else
6566		_somian_kspb_perl=`echo "$_somian_shbangperl" \| sed -ne"s\|.='$$negclass$';$\|\1\|p"`
#	Line 5338 \| Line 6577 \| fi
6577		fi
6578
6579		fi
6580	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
6580	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_kernshrpbang_perl" >&5
6581		$as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
6582		# The above prints Checking ... result message to user.
6583		PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
6584
6585		if test A${_somian_ksbp_warn_empty+set} == Aset
6586	<	then { $as_echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
6586	>	then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
6587		$as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
6588		fi
6589		# Inform user after printing result value
6590		if test A${_somian_ksbp_warn_defau+set} == Aset
6591	<	then { $as_echo "$as_me:$LINENO: Maybe Not good -" >&5
6591	>	then { $as_echo "$as_me:${as_lineno-$LINENO}: Maybe Not good -" >&5
6592		$as_echo "$as_me: Maybe Not good -" >&6;}
6593	<	{ $as_echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
6593	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
6594		$as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
6595	<	else { $as_echo "$as_me:$LINENO: OK Good result - " >&5
6595	>	else { $as_echo "$as_me:${as_lineno-$LINENO}: OK Good result - " >&5
6596		$as_echo "$as_me: OK Good result - " >&6;}
6597	<	{ $as_echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
6597	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
6598		$as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
6599		fi
6600		fi
#	Line 5374 \| Line 6613 \| $as_echo "$as_me: In last check we got a proper-lookin
6613		# OS/2's system install, which has a completely different semantic
6614		# ./install, which can be erroneously created by make from ./install.sh.
6615		# Reject install programs that cannot install multiple files.
6616	<	{ $as_echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6616	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
6617		$as_echo_n "checking for a BSD-compatible install... " >&6; }
6618		if test -z "$INSTALL"; then
6619	<	if test "${ac_cv_path_install+set}" = set; then
6619	>	if test "${ac_cv_path_install+set}" = set; then :
6620		$as_echo_n "(cached) " >&6
6621		else
6622		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
#	Line 5385 \| Line 6624 \| do
6624		do
6625		IFS=$as_save_IFS
6626		test -z "$as_dir" && as_dir=.
6627	<	# Account for people who put trailing slashes in PATH elements.
6628	<	case $as_dir/ in
6629	<	./ \| .// \| /cC/* \| \
6627	>	# Account for people who put trailing slashes in PATH elements.
6628	>	case $as_dir/ in #((
6629	>	./ \| .// \| /[cC]/* \| \
6630		/etc/* \| /usr/sbin/* \| /usr/etc/* \| /sbin/* \| /usr/afsws/bin/* \| \
6631	<	?:\\/os2\\/install\\/* \| ?:\\/OS2\\/INSTALL\\/* \| \
6631	>	?:[\\/]os2[\\/]install[\\/]* \| ?:[\\/]OS2[\\/]INSTALL[\\/]* \| \
6632		/usr/ucb/* ) ;;
6633		*)
6634		# OSF1 and SCO ODT 3.0 have their own names for install.
#	Line 5426 \| Line 6665 \| esac
6665		;;
6666		esac
6667
6668	<	done
6668	>	done
6669		IFS=$as_save_IFS
6670
6671		rm -rf conftest.one conftest.two conftest.dir
#	Line 5442 \| Line 6681 \| fi
6681		INSTALL=$ac_install_sh
6682		fi
6683		fi
6684	<	{ $as_echo "$as_me:$LINENO: result: $INSTALL" >&5
6684	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
6685		$as_echo "$INSTALL" >&6; }
6686
6687		# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
#	Line 5460 \| Line 6699 \| set dummy ar; ac_word=$2
6699		MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
6700		# Extract the first word of "ar", so it can be a program name with args.
6701		set dummy ar; ac_word=$2
6702	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
6702	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6703		$as_echo_n "checking for $ac_word... " >&6; }
6704	<	if test "${ac_cv_prog_AR+set}" = set; then
6704	>	if test "${ac_cv_prog_AR+set}" = set; then :
6705		$as_echo_n "(cached) " >&6
6706		else
6707		if test -n "$AR"; then
#	Line 5473 \| Line 6712 \| do
6712		do
6713		IFS=$as_save_IFS
6714		test -z "$as_dir" && as_dir=.
6715	<	for ac_exec_ext in '' $ac_executable_extensions; do
6715	>	for ac_exec_ext in '' $ac_executable_extensions; do
6716		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6717		ac_cv_prog_AR="ar"
6718	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6718	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6719		break 2
6720		fi
6721		done
6722	<	done
6722	>	done
6723		IFS=$as_save_IFS
6724
6725		test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
#	Line 5488 \| Line 6727 \| if test -n "$AR"; then
6727		fi
6728		AR=$ac_cv_prog_AR
6729		if test -n "$AR"; then
6730	<	{ $as_echo "$as_me:$LINENO: result: $AR" >&5
6730	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
6731		$as_echo "$AR" >&6; }
6732		else
6733	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
6733	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6734		$as_echo "no" >&6; }
6735		fi
6736
#	Line 5524 \| Line 6763 \| _ACEOF
6763		case $ac_val in #(
6764		${as_nl})
6765		case $ac_var in #(
6766	<	_cv_) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
6767	<	$as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
6766	>	_cv_) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
6767	>	$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
6768		esac
6769		case $ac_var in #(
6770		_ \| IFS \| as_nl) ;; #(
6771		BASH_ARGV \| BASH_SOURCE) eval $ac_var= ;; #(
6772	<	*) $as_unset $ac_var ;;
6772	>	*) { eval $ac_var=; unset $ac_var;} ;;
6773		esac ;;
6774		esac
6775		done
#	Line 5538 \| Line 6777 \| $as_echo "$as_me: WARNING: Cache variable $ac_var cont
6777		(set) 2>&1 \|
6778		case $as_nl`(ac_space=' '; set) 2>&1` in #(
6779		${as_nl}ac_space=\ )
6780	<	# `set' does not quote correctly, so add quotes (double-quote
6781	<	# substitution turns \\\\ into \\, and sed turns \\ into \).
6780	>	# `set' does not quote correctly, so add quotes: double-quote
6781	>	# substitution turns \\\\ into \\, and sed turns \\ into \.
6782		sed -n \
6783		"s/'/'\\\\''/g;
6784		s/^\$[_$as_cr_alnum]_cv_[_$as_cr_alnum]\$=\$.*\$/\\1='\\2'/p"
#	Line 5562 \| Line 6801 \| if diff "$cache_file" confcache >/dev/null 2>&1; then
6801		if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
6802		if test -w "$cache_file"; then
6803		test "x$cache_file" != "x/dev/null" &&
6804	<	{ $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
6804	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
6805		$as_echo "$as_me: updating cache $cache_file" >&6;}
6806		cat confcache >$cache_file
6807		else
6808	<	{ $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
6808	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
6809		$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
6810		fi
6811		fi
#	Line 5575 \| Line 6814 \| set dummy ps; ac_word=$2
6814		fi
6815		# Extract the first word of "ps", so it can be a program name with args.
6816		set dummy ps; ac_word=$2
6817	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
6817	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6818		$as_echo_n "checking for $ac_word... " >&6; }
6819	<	if test "${ac_cv_path_PS+set}" = set; then
6819	>	if test "${ac_cv_path_PS+set}" = set; then :
6820		$as_echo_n "(cached) " >&6
6821		else
6822		case $PS in
#	Line 5590 \| Line 6829 \| do
6829		do
6830		IFS=$as_save_IFS
6831		test -z "$as_dir" && as_dir=.
6832	<	for ac_exec_ext in '' $ac_executable_extensions; do
6832	>	for ac_exec_ext in '' $ac_executable_extensions; do
6833		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6834		ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
6835	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6835	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6836		break 2
6837		fi
6838		done
6839	<	done
6839	>	done
6840		IFS=$as_save_IFS
6841
6842		;;
#	Line 5605 \| Line 6844 \| if test -n "$PS"; then
6844		fi
6845		PS=$ac_cv_path_PS
6846		if test -n "$PS"; then
6847	<	{ $as_echo "$as_me:$LINENO: result: $PS" >&5
6847	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PS" >&5
6848		$as_echo "$PS" >&6; }
6849		else
6850	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
6850	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6851		$as_echo "no" >&6; }
6852		fi
6853
6854
6855	<	{ $as_echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
6855	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for POSIX or BSD ps syntax" >&5
6856		$as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
6857	<	if test "${ac_cv_prog_ps_syntax+set}" = set; then
6857	>	if test "${ac_cv_prog_ps_syntax+set}" = set; then :
6858		$as_echo_n "(cached) " >&6
6859		else
6860
#	Line 5635 \| Line 6874 \| else
6874		if test "$ac_cv_prog_ps_ef" = yes; then
6875		ac_cv_prog_ps_syntax=POSIX
6876		else
6877	<	{ { $as_echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
5639	<	$as_echo "$as_me: error: Could not determine ps syntax" >&2;}
5640	<	{ (exit 1); exit 1; }; }
6877	>	as_fn_error "Could not determine ps syntax" "$LINENO" 5
6878		fi
6879		fi
6880
6881		fi
6882	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
6882	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_ps_syntax" >&5
6883		$as_echo "$ac_cv_prog_ps_syntax" >&6; }
6884
6885		cat >>confdefs.h <<_ACEOF
#	Line 5651 \| Line 6888 \| if test "$ac_cv_prog_ps_syntax" = BSD; then
6888
6889		if test "$ac_cv_prog_ps_syntax" = BSD; then
6890
6891	<	cat >>confdefs.h <<\_ACEOF
5655	<	#define PSTYPE_IS_BSD 1
5656	<	_ACEOF
6891	>	$as_echo "#define PSTYPE_IS_BSD 1" >>confdefs.h
6892
6893		else
6894		if test "$ac_cv_prog_ps_syntax" = POSIX; then
6895
6896	<	cat >>confdefs.h <<\_ACEOF
5662	<	#define PSTYPE_IS_POSIX 1
5663	<	_ACEOF
6896	>	$as_echo "#define PSTYPE_IS_POSIX 1" >>confdefs.h
6897
6898		else
6899	<	{ { $as_echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
5667	<	$as_echo "$as_me: error: Unknown ps syntax type!" >&2;}
5668	<	{ (exit 1); exit 1; }; }
6899	>	as_fn_error "Unknown ps syntax type!" "$LINENO" 5
6900		fi
6901		fi
6902
#	Line 5674 \| Line 6905 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6905		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6906		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6907
5677	–
6908		ac_ext=${ac_fc_srcext-f}
6909		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6910		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6911		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6912	<	{ $as_echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
6912	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran flag to compile .F90 files" >&5
6913		$as_echo_n "checking for Fortran flag to compile .F90 files... " >&6; }
6914	<	if test "${ac_cv_fc_srcext_F90+set}" = set; then
6914	>	if test "${ac_cv_fc_srcext_F90+set}" = set; then :
6915		$as_echo_n "(cached) " >&6
6916		else
6917		ac_ext=F90
#	Line 5690 \| Line 6920 \| for ac_flag in none -qsuffix=f=F90 -Tf; do
6920		ac_cv_fc_srcext_F90=unknown
6921		for ac_flag in none -qsuffix=f=F90 -Tf; do
6922		test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
6923	<	cat >conftest.$ac_ext <<_ACEOF
6923	>	cat > conftest.$ac_ext <<_ACEOF
6924		program main
6925
6926		end
6927		_ACEOF
6928	<	rm -f conftest.$ac_objext
5699	<	if { (ac_try="$ac_compile"
5700	<	case "(($ac_try" in
5701	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
5702	<	*) ac_try_echo=$ac_try;;
5703	<	esac
5704	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5705	<	$as_echo "$ac_try_echo") >&5
5706	<	(eval "$ac_compile") 2>conftest.er1
5707	<	ac_status=$?
5708	<	grep -v '^ *+' conftest.er1 >conftest.err
5709	<	rm -f conftest.er1
5710	<	cat conftest.err >&5
5711	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5712	<	(exit $ac_status); } && {
5713	<	test -z "$ac_fc_werror_flag" \|\|
5714	<	test ! -s conftest.err
5715	<	} && test -s conftest.$ac_objext; then
6928	>	if ac_fn_fc_try_compile "$LINENO"; then :
6929		ac_cv_fc_srcext_F90=$ac_flag; break
5717	–	else
5718	–	$as_echo "$as_me: failed program was:" >&5
5719	–	sed 's/^/\| /' conftest.$ac_ext >&5
5720	–
5721	–
6930		fi
5723	–
6931		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6932		done
6933		rm -f conftest.$ac_objext conftest.F90
6934		ac_fcflags_srcext=$ac_fcflags_srcext_save
6935
6936		fi
6937	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
6937	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_srcext_F90" >&5
6938		$as_echo "$ac_cv_fc_srcext_F90" >&6; }
6939		if test "x$ac_cv_fc_srcext_F90" = xunknown; then
6940	<	{ { $as_echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
5734	<	$as_echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
5735	<	{ (exit 1); exit 1; }; }
6940	>	as_fn_error "Fortran could not compile .F90 files" "$LINENO" 5
6941		else
6942		ac_fc_srcext=F90
6943		if test "x$ac_cv_fc_srcext_F90" = xnone; then
#	Line 5774 \| Line 6979 \| if test "$ac_test_PREPFLAG" != "set"; then
6979		esac
6980
6981		if test -z "$PREPFLAG"; then
6982	<	{ $as_echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
6982	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Using empty PREPFLAG\"" >&5
6983		$as_echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
6984		PREPFLAG=""
6985		fi
6986
6987	<	{ $as_echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
6987	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking to make sure F90 preprocessor flag works" >&5
6988		$as_echo_n "checking to make sure F90 preprocessor flag works... " >&6; }
6989
6990		ac_ext=${ac_fc_srcext-f}
#	Line 5791 \| Line 6996 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6996		ac_ext=F90
6997		ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
6998
6999	<	if test "$PREPFLAG"; then
6999	>	if test "$PREPFLAG"; then :
7000		FCFLAGS_SRCEXT="${PREPFLAG}"
7001		fi
7002	+	cat > conftest.$ac_ext <<_ACEOF
7003
5798	–	cat >conftest.$ac_ext <<_ACEOF
7004
5800	–
7005		program conftest
7006		integer :: i
7007		i = 1
7008		end program conftest
7009
7010		_ACEOF
7011	<	rm -f conftest.$ac_objext
5808	<	if { (ac_try="$ac_compile"
5809	<	case "(($ac_try" in
5810	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
5811	<	*) ac_try_echo=$ac_try;;
5812	<	esac
5813	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5814	<	$as_echo "$ac_try_echo") >&5
5815	<	(eval "$ac_compile") 2>conftest.er1
5816	<	ac_status=$?
5817	<	grep -v '^ *+' conftest.er1 >conftest.err
5818	<	rm -f conftest.er1
5819	<	cat conftest.err >&5
5820	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5821	<	(exit $ac_status); } && {
5822	<	test -z "$ac_fc_werror_flag" \|\|
5823	<	test ! -s conftest.err
5824	<	} && test -s conftest.$ac_objext; then
7011	>	if ac_fn_fc_try_compile "$LINENO"; then :
7012		prepflagworks=1
7013		else
7014	<	$as_echo "$as_me: failed program was:" >&5
5828	<	sed 's/^/\| /' conftest.$ac_ext >&5
5829	<
5830	<	prepflagworks=0
7014	>	prepflagworks=0
7015		fi
5832	–
7016		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7017
7018		FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
#	Line 5841 \| Line 7024 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7024
7025
7026		if test "$prepflagworks" = 1; then
7027	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
7027	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
7028		$as_echo "yes" >&6; }
7029		FCFLAGS_SRCEXT="${PREPFLAG}"
7030
7031		else
7032	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
7032	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7033		$as_echo "no" >&6; }
7034	<	{ { $as_echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
5852	<	$as_echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
5853	<	{ (exit 1); exit 1; }; }
7034	>	as_fn_error "Can't figure out working Fortran90 preprocessor flag" "$LINENO" 5
7035		fi
7036		fi
7037
#	Line 5878 \| Line 7059 \| if test "$ac_test_PREPDEFFLAG" != "set"; then
7059		esac
7060
7061		if test -z "$PREPDEFFLAG"; then
7062	<	{ $as_echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
7062	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Using empty PREPDEFFLAG\"" >&5
7063		$as_echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
7064		PREPDEFFLAG=" "
7065		fi
7066
7067	<	{ $as_echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
7067	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking to make sure F90 preprocessor define flag works" >&5
7068		$as_echo_n "checking to make sure F90 preprocessor define flag works... " >&6; }
7069
7070		ac_ext=${ac_fc_srcext-f}
#	Line 5895 \| Line 7076 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7076		ac_ext=F90
7077		ac_save_FCFLAGS=$FCFLAGS
7078
7079	<	if test "$PREPDEFFLAG"; then
7079	>	if test "$PREPDEFFLAG"; then :
7080		FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
7081		fi
7082	+	cat > conftest.$ac_ext <<_ACEOF
7083
5902	–	cat >conftest.$ac_ext <<_ACEOF
7084
5904	–
7085		program conftest
7086		integer :: i
7087		#ifdef TEST
#	Line 5912 \| Line 7092 \| _ACEOF
7092		end program conftest
7093
7094		_ACEOF
7095	<	rm -f conftest.$ac_objext
5916	<	if { (ac_try="$ac_compile"
5917	<	case "(($ac_try" in
5918	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
5919	<	*) ac_try_echo=$ac_try;;
5920	<	esac
5921	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5922	<	$as_echo "$ac_try_echo") >&5
5923	<	(eval "$ac_compile") 2>conftest.er1
5924	<	ac_status=$?
5925	<	grep -v '^ *+' conftest.er1 >conftest.err
5926	<	rm -f conftest.er1
5927	<	cat conftest.err >&5
5928	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5929	<	(exit $ac_status); } && {
5930	<	test -z "$ac_fc_werror_flag" \|\|
5931	<	test ! -s conftest.err
5932	<	} && test -s conftest.$ac_objext; then
7095	>	if ac_fn_fc_try_compile "$LINENO"; then :
7096		prepdefflagworks=1
7097		else
7098	<	$as_echo "$as_me: failed program was:" >&5
5936	<	sed 's/^/\| /' conftest.$ac_ext >&5
5937	<
5938	<	prepdefflagworks=0
7098	>	prepdefflagworks=0
7099		fi
5940	–
7100		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7101
7102		FCFLAGS=$ac_save_FCFLAGS
#	Line 5949 \| Line 7108 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7108
7109
7110		if test "$prepdefflagworks" = 1; then
7111	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
7111	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
7112		$as_echo "yes" >&6; }
7113
7114		else
7115	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
7115	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7116		$as_echo "no" >&6; }
7117	<	{ { $as_echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
5959	<	$as_echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
5960	<	{ (exit 1); exit 1; }; }
7117	>	as_fn_error "Can't figure out working Fortran90 preprocessor define flag" "$LINENO" 5
7118		fi
7119		fi
7120
#	Line 5965 \| Line 7122 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7122		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7123		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7124		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7125	<	{ $as_echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
7125	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to get verbose linking output from $FC" >&5
7126		$as_echo_n "checking how to get verbose linking output from $FC... " >&6; }
7127	<	if test "${ac_cv_prog_fc_v+set}" = set; then
7127	>	if test "${ac_cv_prog_fc_v+set}" = set; then :
7128		$as_echo_n "(cached) " >&6
7129		else
7130	<	cat >conftest.$ac_ext <<_ACEOF
7130	>	cat > conftest.$ac_ext <<_ACEOF
7131		program main
7132
7133		end
7134		_ACEOF
7135	<	rm -f conftest.$ac_objext
5979	<	if { (ac_try="$ac_compile"
5980	<	case "(($ac_try" in
5981	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
5982	<	*) ac_try_echo=$ac_try;;
5983	<	esac
5984	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5985	<	$as_echo "$ac_try_echo") >&5
5986	<	(eval "$ac_compile") 2>conftest.er1
5987	<	ac_status=$?
5988	<	grep -v '^ *+' conftest.er1 >conftest.err
5989	<	rm -f conftest.er1
5990	<	cat conftest.err >&5
5991	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5992	<	(exit $ac_status); } && {
5993	<	test -z "$ac_fc_werror_flag" \|\|
5994	<	test ! -s conftest.err
5995	<	} && test -s conftest.$ac_objext; then
7135	>	if ac_fn_fc_try_compile "$LINENO"; then :
7136		ac_cv_prog_fc_v=
7137		# Try some options frequently used verbose output
7138		for ac_verb in -v -verbose --verbose -V -\#\#\#; do
7139	<	cat >conftest.$ac_ext <<_ACEOF
7139	>	cat > conftest.$ac_ext <<_ACEOF
7140		program main
7141
7142		end
#	Line 6006 \| Line 7146 \| _ACEOF
7146		# 1 to this macro) to the Fortran compiler in order to get
7147		# "verbose" output that we can then parse for the Fortran linker
7148		# flags.
7149	<	ac_save_FFLAGS=$FCFLAGS
7149	>	ac_save_FCFLAGS=$FCFLAGS
7150		FCFLAGS="$FCFLAGS $ac_verb"
7151		eval "set x $ac_link"
7152		shift
7153	<	$as_echo "$as_me:$LINENO: $*" >&5
7153	>	$as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7154		# gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7155		# LIBRARY_PATH; skip all such settings.
7156		ac_fc_v_output=`eval $ac_link 5>&1 2>&1 \|
7157		grep -v 'Driving:' \| grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7158		$as_echo "$ac_fc_v_output" >&5
7159	<	FCFLAGS=$ac_save_FFLAGS
7159	>	FCFLAGS=$ac_save_FCFLAGS
7160
7161		rm -rf conftest*
7162
#	Line 6045 \| Line 7185 \| case $ac_fc_v_output in
7185		# Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7186		-cmdline\ \| -ignore\ \| -def\ )
7187		ac_fc_v_output=`echo $ac_fc_v_output \| sed "\
7188	<	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7189	<	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7190	<	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7188	>	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7189	>	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7190	>	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7191
7192		# If we are using Cray Fortran then delete quotes.
7193		cft90)
#	Line 6058 \| Line 7198 \| esac
7198		# look for -l* and *.a constructs in the output
7199		for ac_arg in $ac_fc_v_output; do
7200		case $ac_arg in
7201	<	[\\/].a \| ?:[\\/].a \| -[lLRu]*)
7202	<	ac_cv_prog_fc_v=$ac_verb
7203	<	break 2 ;;
7201	>	[\\/].a \| ?:[\\/].a \| -[lLRu]*)
7202	>	ac_cv_prog_fc_v=$ac_verb
7203	>	break 2 ;;
7204		esac
7205		done
7206		done
7207		if test -z "$ac_cv_prog_fc_v"; then
7208	<	{ $as_echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
7208	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot determine how to obtain linking information from $FC" >&5
7209		$as_echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
7210		fi
7211		else
7212	<	$as_echo "$as_me: failed program was:" >&5
6073	<	sed 's/^/\| /' conftest.$ac_ext >&5
6074	<
6075	<	{ $as_echo "$as_me:$LINENO: WARNING: compilation failed" >&5
7212	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: compilation failed" >&5
7213		$as_echo "$as_me: WARNING: compilation failed" >&2;}
7214		fi
6078	–
7215		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7216
7217		fi
7218	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
7218	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_v" >&5
7219		$as_echo "$ac_cv_prog_fc_v" >&6; }
7220	<	{ $as_echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
7220	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran libraries of $FC" >&5
7221		$as_echo_n "checking for Fortran libraries of $FC... " >&6; }
7222	<	if test "${ac_cv_fc_libs+set}" = set; then
7222	>	if test "${ac_cv_fc_libs+set}" = set; then :
7223		$as_echo_n "(cached) " >&6
7224		else
7225		if test "x$FCLIBS" != "x"; then
7226		ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
7227		else
7228
7229	<	cat >conftest.$ac_ext <<_ACEOF
7229	>	cat > conftest.$ac_ext <<_ACEOF
7230		program main
7231
7232		end
#	Line 6100 \| Line 7236 \| _ACEOF
7236		# 1 to this macro) to the Fortran compiler in order to get
7237		# "verbose" output that we can then parse for the Fortran linker
7238		# flags.
7239	<	ac_save_FFLAGS=$FCFLAGS
7239	>	ac_save_FCFLAGS=$FCFLAGS
7240		FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
7241		eval "set x $ac_link"
7242		shift
7243	<	$as_echo "$as_me:$LINENO: $*" >&5
7243	>	$as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7244		# gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7245		# LIBRARY_PATH; skip all such settings.
7246		ac_fc_v_output=`eval $ac_link 5>&1 2>&1 \|
7247		grep -v 'Driving:' \| grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7248		$as_echo "$ac_fc_v_output" >&5
7249	<	FCFLAGS=$ac_save_FFLAGS
7249	>	FCFLAGS=$ac_save_FCFLAGS
7250
7251		rm -rf conftest*
7252
#	Line 6139 \| Line 7275 \| case $ac_fc_v_output in
7275		# Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7276		-cmdline\ \| -ignore\ \| -def\ )
7277		ac_fc_v_output=`echo $ac_fc_v_output \| sed "\
7278	<	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7279	<	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7280	<	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7278	>	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7279	>	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7280	>	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7281
7282		# If we are using Cray Fortran then delete quotes.
7283		cft90)
#	Line 6160 \| Line 7296 \| while test $# != 1; do
7296		shift
7297		ac_arg=$1
7298		case $ac_arg in
7299	<	[\\/].a \| ?:[\\/].a)
7300	<	ac_exists=false
7299	>	[\\/].a \| ?:[\\/].a)
7300	>	ac_exists=false
7301		for ac_i in $ac_cv_fc_libs; do
7302		if test x"$ac_arg" = x"$ac_i"; then
7303		ac_exists=true
#	Line 6169 \| Line 7305 \| while test $# != 1; do
7305		fi
7306		done
7307
7308	<	if test x"$ac_exists" = xtrue; then
7309	<	:
7308	>	if test x"$ac_exists" = xtrue; then :
7309	>
7310		else
7311		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7312		fi
7313	<
7314	<	;;
7315	<	-bI:*)
6180	<	ac_exists=false
7313	>	;;
7314	>	-bI:*)
7315	>	ac_exists=false
7316		for ac_i in $ac_cv_fc_libs; do
7317		if test x"$ac_arg" = x"$ac_i"; then
7318		ac_exists=true
#	Line 6185 \| Line 7320 \| fi
7320		fi
7321		done
7322
7323	<	if test x"$ac_exists" = xtrue; then
7324	<	:
7323	>	if test x"$ac_exists" = xtrue; then :
7324	>
7325		else
7326		if test "$ac_compiler_gnu" = yes; then
7327		for ac_link_opt in $ac_arg; do
#	Line 6196 \| Line 7331 \| fi
7331		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7332		fi
7333		fi
7334	<
7335	<	;;
7336	<	# Ignore these flags.
7337	<	-lang* \| -lcrt.o \| -lc \| -lgcc \| -lSystem \| -libmil \| -LANG:=* \| -LIST:* \| -LNO:*)
7338	<	;;
7339	<	-lkernel32)
7340	<	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7341	<	;;
7342	<	-[LRuYz])
7343	<	# These flags, when seen by themselves, take an argument.
7344	<	# We remove the space between option and argument and re-iterate
7345	<	# unless we find an empty arg or a new option (starting with -)
7334	>	;;
7335	>	# Ignore these flags.
7336	>	-lang* \| -lcrt.o \| -lc \| -lgcc \| -lSystem \| -libmil \| -little \
7337	>	\|-LANG:=* \| -LIST:* \| -LNO:*)
7338	>	;;
7339	>	-lkernel32)
7340	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7341	>	;;
7342	>	-[LRuYz])
7343	>	# These flags, when seen by themselves, take an argument.
7344	>	# We remove the space between option and argument and re-iterate
7345	>	# unless we find an empty arg or a new option (starting with -)
7346		case $2 in
7347		"" \| -*);;
7348		*)
#	Line 6216 \| Line 7351 \| fi
7351		set X $ac_arg "$@"
7352		;;
7353		esac
7354	<	;;
7355	<	-YP,*)
7356	<	for ac_j in `$as_echo "$ac_arg" \| sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7357	<	ac_exists=false
7354	>	;;
7355	>	-YP,*)
7356	>	for ac_j in `$as_echo "$ac_arg" \| sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7357	>	ac_exists=false
7358		for ac_i in $ac_cv_fc_libs; do
7359		if test x"$ac_j" = x"$ac_i"; then
7360		ac_exists=true
#	Line 6227 \| Line 7362 \| fi
7362		fi
7363		done
7364
7365	<	if test x"$ac_exists" = xtrue; then
7366	<	:
7365	>	if test x"$ac_exists" = xtrue; then :
7366	>
7367		else
7368		ac_arg="$ac_arg $ac_j"
7369	<	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
7369	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
7370		fi
7371	<
7372	<	done
7373	<	;;
7374	<	-[lLR]*)
6240	<	ac_exists=false
7371	>	done
7372	>	;;
7373	>	-[lLR]*)
7374	>	ac_exists=false
7375		for ac_i in $ac_cv_fc_libs; do
7376		if test x"$ac_arg" = x"$ac_i"; then
7377		ac_exists=true
#	Line 6245 \| Line 7379 \| fi
7379		fi
7380		done
7381
7382	<	if test x"$ac_exists" = xtrue; then
7383	<	:
7382	>	if test x"$ac_exists" = xtrue; then :
7383	>
7384		else
7385		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7386		fi
7387	<
6254	<	;;
7387	>	;;
7388		-zallextract*\| -zdefaultextract)
7389		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7390		;;
7391	<	# Ignore everything else.
7391	>	# Ignore everything else.
7392		esac
7393		done
7394		# restore positional arguments
#	Line 6267 \| Line 7400 \| case `(uname -sr) 2>/dev/null` in
7400		case `(uname -sr) 2>/dev/null` in
7401		"SunOS 5"*)
7402		ac_ld_run_path=`$as_echo "$ac_fc_v_output" \|
7403	<	sed -n 's,^.LD_RUN_PATH = $/[^ ]$.*$,-R\1,p'`
7403	>	sed -n 's,^.LD_RUN_PATH = $/[^ ]$.*$,-R\1,p'`
7404		test "x$ac_ld_run_path" != x &&
7405	<	if test "$ac_compiler_gnu" = yes; then
7405	>	if test "$ac_compiler_gnu" = yes; then
7406		for ac_link_opt in $ac_ld_run_path; do
7407		ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
7408		done
#	Line 6281 \| Line 7414 \| fi
7414		fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
7415
7416		fi
7417	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
7417	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_libs" >&5
7418		$as_echo "$ac_cv_fc_libs" >&6; }
7419		FCLIBS="$ac_cv_fc_libs"
7420
#	Line 6291 \| Line 7424 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7424		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7425		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7426
6294	–
7427		ac_ext=${ac_fc_srcext-f}
7428		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7429		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7430		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7431
7432	<	{ $as_echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
7432	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dummy main to link with Fortran libraries" >&5
7433		$as_echo_n "checking for dummy main to link with Fortran libraries... " >&6; }
7434	<	if test "${ac_cv_fc_dummy_main+set}" = set; then
7434	>	if test "${ac_cv_fc_dummy_main+set}" = set; then :
7435		$as_echo_n "(cached) " >&6
7436		else
7437		ac_fc_dm_save_LIBS=$LIBS
#	Line 6312 \| Line 7444 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
7444		ac_compiler_gnu=$ac_cv_c_compiler_gnu
7445
7446		# First, try linking without a dummy main:
7447	<	cat >conftest.$ac_ext <<_ACEOF
6316	<	/* confdefs.h. */
6317	<	_ACEOF
6318	<	cat confdefs.h >>conftest.$ac_ext
6319	<	cat >>conftest.$ac_ext <<_ACEOF
7447	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7448		/* end confdefs.h. */
7449
7450		#ifdef FC_DUMMY_MAIN
#	Line 6335 \| Line 7463 \| _ACEOF
7463		return 0;
7464		}
7465		_ACEOF
7466	<	rm -f conftest.$ac_objext conftest$ac_exeext
6339	<	if { (ac_try="$ac_link"
6340	<	case "(($ac_try" in
6341	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
6342	<	*) ac_try_echo=$ac_try;;
6343	<	esac
6344	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6345	<	$as_echo "$ac_try_echo") >&5
6346	<	(eval "$ac_link") 2>conftest.er1
6347	<	ac_status=$?
6348	<	grep -v '^ *+' conftest.er1 >conftest.err
6349	<	rm -f conftest.er1
6350	<	cat conftest.err >&5
6351	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6352	<	(exit $ac_status); } && {
6353	<	test -z "$ac_c_werror_flag" \|\|
6354	<	test ! -s conftest.err
6355	<	} && test -s conftest$ac_exeext && {
6356	<	test "$cross_compiling" = yes \|\|
6357	<	$as_test_x conftest$ac_exeext
6358	<	}; then
7466	>	if ac_fn_c_try_link "$LINENO"; then :
7467		ac_cv_fortran_dummy_main=none
7468		else
7469	<	$as_echo "$as_me: failed program was:" >&5
6362	<	sed 's/^/\| /' conftest.$ac_ext >&5
6363	<
6364	<	ac_cv_fortran_dummy_main=unknown
7469	>	ac_cv_fortran_dummy_main=unknown
7470		fi
7471	+	rm -f core conftest.err conftest.$ac_objext \
7472	+	conftest$ac_exeext conftest.$ac_ext
7473
6367	–	rm -rf conftest.dSYM
6368	–	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6369	–	conftest$ac_exeext conftest.$ac_ext
6370	–
7474		if test $ac_cv_fortran_dummy_main = unknown; then
7475		for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
7476	<	cat >conftest.$ac_ext <<_ACEOF
6374	<	/* confdefs.h. */
6375	<	_ACEOF
6376	<	cat confdefs.h >>conftest.$ac_ext
6377	<	cat >>conftest.$ac_ext <<_ACEOF
7476	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7477		/* end confdefs.h. */
7478		#define $ac_fortran_dm_var $ac_func
7479		#ifdef FC_DUMMY_MAIN
#	Line 6393 \| Line 7492 \| _ACEOF
7492		return 0;
7493		}
7494		_ACEOF
7495	<	rm -f conftest.$ac_objext conftest$ac_exeext
6397	<	if { (ac_try="$ac_link"
6398	<	case "(($ac_try" in
6399	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
6400	<	*) ac_try_echo=$ac_try;;
6401	<	esac
6402	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6403	<	$as_echo "$ac_try_echo") >&5
6404	<	(eval "$ac_link") 2>conftest.er1
6405	<	ac_status=$?
6406	<	grep -v '^ *+' conftest.er1 >conftest.err
6407	<	rm -f conftest.er1
6408	<	cat conftest.err >&5
6409	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6410	<	(exit $ac_status); } && {
6411	<	test -z "$ac_c_werror_flag" \|\|
6412	<	test ! -s conftest.err
6413	<	} && test -s conftest$ac_exeext && {
6414	<	test "$cross_compiling" = yes \|\|
6415	<	$as_test_x conftest$ac_exeext
6416	<	}; then
7495	>	if ac_fn_c_try_link "$LINENO"; then :
7496		ac_cv_fortran_dummy_main=$ac_func; break
6418	–	else
6419	–	$as_echo "$as_me: failed program was:" >&5
6420	–	sed 's/^/\| /' conftest.$ac_ext >&5
6421	–
6422	–
7497		fi
7498	<
7499	<	rm -rf conftest.dSYM
6426	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6427	<	conftest$ac_exeext conftest.$ac_ext
7498	>	rm -f core conftest.err conftest.$ac_objext \
7499	>	conftest$ac_exeext conftest.$ac_ext
7500		done
7501		fi
7502		ac_ext=${ac_fc_srcext-f}
#	Line 6436 \| Line 7508 \| fi
7508		LIBS=$ac_fc_dm_save_LIBS
7509
7510		fi
7511	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
7511	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_dummy_main" >&5
7512		$as_echo "$ac_cv_fc_dummy_main" >&6; }
7513		FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
7514	<	if test "$FC_DUMMY_MAIN" != unknown; then
7514	>	if test "$FC_DUMMY_MAIN" != unknown; then :
7515		if test $FC_DUMMY_MAIN != none; then
7516
7517		cat >>confdefs.h <<_ACEOF
#	Line 6448 \| Line 7520 \| _ACEOF
7520
7521		if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
7522
7523	<	cat >>confdefs.h <<\_ACEOF
6452	<	#define FC_DUMMY_MAIN_EQ_F77 1
6453	<	_ACEOF
7523	>	$as_echo "#define FC_DUMMY_MAIN_EQ_F77 1" >>confdefs.h
7524
7525		fi
7526		fi
7527		else
7528	<	{ { $as_echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
7529	<	See \`config.log' for more details." >&5
7530	<	$as_echo "$as_me: error: linking to Fortran libraries from C fails
7531	<	See \`config.log' for more details." >&2;}
6462	<	{ (exit 1); exit 1; }; }
7528	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
7529	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
7530	>	as_fn_error "linking to Fortran libraries from C fails
7531	>	See \`config.log' for more details." "$LINENO" 5; }
7532		fi
7533
6465	–
7534		ac_ext=${ac_fc_srcext-f}
7535		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7536		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
#	Line 6472 \| Line 7540 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7540		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7541		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7542		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7543	<	{ $as_echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
7543	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran name-mangling scheme" >&5
7544		$as_echo_n "checking for Fortran name-mangling scheme... " >&6; }
7545	<	if test "${ac_cv_fc_mangling+set}" = set; then
7545	>	if test "${ac_cv_fc_mangling+set}" = set; then :
7546		$as_echo_n "(cached) " >&6
7547		else
7548	<	cat >conftest.$ac_ext <<_ACEOF
7548	>	cat > conftest.$ac_ext <<_ACEOF
7549		subroutine foobar()
7550		return
7551		end
#	Line 6485 \| Line 7553 \| _ACEOF
7553		return
7554		end
7555		_ACEOF
7556	<	rm -f conftest.$ac_objext
6489	<	if { (ac_try="$ac_compile"
6490	<	case "(($ac_try" in
6491	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
6492	<	*) ac_try_echo=$ac_try;;
6493	<	esac
6494	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6495	<	$as_echo "$ac_try_echo") >&5
6496	<	(eval "$ac_compile") 2>conftest.er1
6497	<	ac_status=$?
6498	<	grep -v '^ *+' conftest.er1 >conftest.err
6499	<	rm -f conftest.er1
6500	<	cat conftest.err >&5
6501	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6502	<	(exit $ac_status); } && {
6503	<	test -z "$ac_fc_werror_flag" \|\|
6504	<	test ! -s conftest.err
6505	<	} && test -s conftest.$ac_objext; then
7556	>	if ac_fn_fc_try_compile "$LINENO"; then :
7557		mv conftest.$ac_objext cfortran_test.$ac_objext
7558
7559		ac_save_LIBS=$LIBS
#	Line 6517 \| Line 7568 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
7568		for ac_foobar in foobar FOOBAR; do
7569		for ac_underscore in "" "_"; do
7570		ac_func="$ac_foobar$ac_underscore"
7571	<	cat >conftest.$ac_ext <<_ACEOF
6521	<	/* confdefs.h. */
6522	<	_ACEOF
6523	<	cat confdefs.h >>conftest.$ac_ext
6524	<	cat >>conftest.$ac_ext <<_ACEOF
7571	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7572		/* end confdefs.h. */
7573
7574		/* Override any GCC internal prototype to avoid an error.
#	Line 6547 \| Line 7594 \| _ACEOF
7594		return 0;
7595		}
7596		_ACEOF
7597	<	rm -f conftest.$ac_objext conftest$ac_exeext
6551	<	if { (ac_try="$ac_link"
6552	<	case "(($ac_try" in
6553	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
6554	<	*) ac_try_echo=$ac_try;;
6555	<	esac
6556	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6557	<	$as_echo "$ac_try_echo") >&5
6558	<	(eval "$ac_link") 2>conftest.er1
6559	<	ac_status=$?
6560	<	grep -v '^ *+' conftest.er1 >conftest.err
6561	<	rm -f conftest.er1
6562	<	cat conftest.err >&5
6563	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6564	<	(exit $ac_status); } && {
6565	<	test -z "$ac_c_werror_flag" \|\|
6566	<	test ! -s conftest.err
6567	<	} && test -s conftest$ac_exeext && {
6568	<	test "$cross_compiling" = yes \|\|
6569	<	$as_test_x conftest$ac_exeext
6570	<	}; then
7597	>	if ac_fn_c_try_link "$LINENO"; then :
7598		ac_success=yes; break 2
6572	–	else
6573	–	$as_echo "$as_me: failed program was:" >&5
6574	–	sed 's/^/\| /' conftest.$ac_ext >&5
6575	–
6576	–
7599		fi
7600	<
7601	<	rm -rf conftest.dSYM
6580	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6581	<	conftest$ac_exeext conftest.$ac_ext
7600	>	rm -f core conftest.err conftest.$ac_objext \
7601	>	conftest$ac_exeext conftest.$ac_ext
7602		done
7603		done
7604		ac_ext=${ac_fc_srcext-f}
#	Line 6606 \| Line 7626 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
7626		ac_success_extra=no
7627		for ac_extra in "" "_"; do
7628		ac_func="$ac_foo_bar$ac_underscore$ac_extra"
7629	<	cat >conftest.$ac_ext <<_ACEOF
6610	<	/* confdefs.h. */
6611	<	_ACEOF
6612	<	cat confdefs.h >>conftest.$ac_ext
6613	<	cat >>conftest.$ac_ext <<_ACEOF
7629	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7630		/* end confdefs.h. */
7631
7632		/* Override any GCC internal prototype to avoid an error.
#	Line 6636 \| Line 7652 \| _ACEOF
7652		return 0;
7653		}
7654		_ACEOF
7655	<	rm -f conftest.$ac_objext conftest$ac_exeext
6640	<	if { (ac_try="$ac_link"
6641	<	case "(($ac_try" in
6642	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
6643	<	*) ac_try_echo=$ac_try;;
6644	<	esac
6645	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6646	<	$as_echo "$ac_try_echo") >&5
6647	<	(eval "$ac_link") 2>conftest.er1
6648	<	ac_status=$?
6649	<	grep -v '^ *+' conftest.er1 >conftest.err
6650	<	rm -f conftest.er1
6651	<	cat conftest.err >&5
6652	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653	<	(exit $ac_status); } && {
6654	<	test -z "$ac_c_werror_flag" \|\|
6655	<	test ! -s conftest.err
6656	<	} && test -s conftest$ac_exeext && {
6657	<	test "$cross_compiling" = yes \|\|
6658	<	$as_test_x conftest$ac_exeext
6659	<	}; then
7655	>	if ac_fn_c_try_link "$LINENO"; then :
7656		ac_success_extra=yes; break
6661	–	else
6662	–	$as_echo "$as_me: failed program was:" >&5
6663	–	sed 's/^/\| /' conftest.$ac_ext >&5
6664	–
6665	–
7657		fi
7658	<
7659	<	rm -rf conftest.dSYM
6669	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6670	<	conftest$ac_exeext conftest.$ac_ext
7658	>	rm -f core conftest.err conftest.$ac_objext \
7659	>	conftest$ac_exeext conftest.$ac_ext
7660		done
7661		ac_ext=${ac_fc_srcext-f}
7662		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
#	Line 6676 \| Line 7665 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7665
7666		if test "$ac_success_extra" = "yes"; then
7667		ac_cv_fc_mangling="$ac_case case"
7668	<	if test -z "$ac_underscore"; then
7669	<	ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
7668	>	if test -z "$ac_underscore"; then
7669	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
7670		else
7671	<	ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
7672	<	fi
7673	<	if test -z "$ac_extra"; then
7674	<	ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
7671	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
7672	>	fi
7673	>	if test -z "$ac_extra"; then
7674	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
7675		else
7676	<	ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
7677	<	fi
7676	>	ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
7677	>	fi
7678		else
7679		ac_cv_fc_mangling="unknown"
7680		fi
#	Line 6697 \| Line 7686 \| else
7686		rm -rf conftest*
7687		rm -f cfortran_test*
7688		else
7689	<	$as_echo "$as_me: failed program was:" >&5
7690	<	sed 's/^/\| /' conftest.$ac_ext >&5
7691	<
7692	<	{ { $as_echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
6704	<	See \`config.log' for more details." >&5
6705	<	$as_echo "$as_me: error: cannot compile a simple Fortran program
6706	<	See \`config.log' for more details." >&2;}
6707	<	{ (exit 1); exit 1; }; }
7689	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
7690	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
7691	>	as_fn_error "cannot compile a simple Fortran program
7692	>	See \`config.log' for more details." "$LINENO" 5; }
7693		fi
6709	–
7694		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7695
7696		fi
7697	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
7697	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_mangling" >&5
7698		$as_echo "$ac_cv_fc_mangling" >&6; }
7699
7700		ac_ext=${ac_fc_srcext-f}
#	Line 6722 \| Line 7706 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7706		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7707		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7708		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6725	–
6726	–
7709		case $ac_cv_fc_mangling in
7710		"lower case, no underscore, no extra underscore")
7711	<	cat >>confdefs.h <<\_ACEOF
6730	<	#define FC_FUNC(name,NAME) name
6731	<	_ACEOF
7711	>	$as_echo "#define FC_FUNC(name,NAME) name" >>confdefs.h
7712
7713	<	cat >>confdefs.h <<\_ACEOF
6734	<	#define FC_FUNC_(name,NAME) name
6735	<	_ACEOF
7713	>	$as_echo "#define FC_FUNC_(name,NAME) name" >>confdefs.h
7714		;;
7715		"lower case, no underscore, extra underscore")
7716	<	cat >>confdefs.h <<\_ACEOF
6739	<	#define FC_FUNC(name,NAME) name
6740	<	_ACEOF
7716	>	$as_echo "#define FC_FUNC(name,NAME) name" >>confdefs.h
7717
7718	<	cat >>confdefs.h <<\_ACEOF
6743	<	#define FC_FUNC_(name,NAME) name ## _
6744	<	_ACEOF
7718	>	$as_echo "#define FC_FUNC_(name,NAME) name ## _" >>confdefs.h
7719		;;
7720		"lower case, underscore, no extra underscore")
7721	<	cat >>confdefs.h <<\_ACEOF
6748	<	#define FC_FUNC(name,NAME) name ## _
6749	<	_ACEOF
7721	>	$as_echo "#define FC_FUNC(name,NAME) name ## _" >>confdefs.h
7722
7723	<	cat >>confdefs.h <<\_ACEOF
6752	<	#define FC_FUNC_(name,NAME) name ## _
6753	<	_ACEOF
7723	>	$as_echo "#define FC_FUNC_(name,NAME) name ## _" >>confdefs.h
7724		;;
7725		"lower case, underscore, extra underscore")
7726	<	cat >>confdefs.h <<\_ACEOF
6757	<	#define FC_FUNC(name,NAME) name ## _
6758	<	_ACEOF
7726	>	$as_echo "#define FC_FUNC(name,NAME) name ## _" >>confdefs.h
7727
7728	<	cat >>confdefs.h <<\_ACEOF
6761	<	#define FC_FUNC_(name,NAME) name ## __
6762	<	_ACEOF
7728	>	$as_echo "#define FC_FUNC_(name,NAME) name ## __" >>confdefs.h
7729		;;
7730		"upper case, no underscore, no extra underscore")
7731	<	cat >>confdefs.h <<\_ACEOF
6766	<	#define FC_FUNC(name,NAME) NAME
6767	<	_ACEOF
7731	>	$as_echo "#define FC_FUNC(name,NAME) NAME" >>confdefs.h
7732
7733	<	cat >>confdefs.h <<\_ACEOF
6770	<	#define FC_FUNC_(name,NAME) NAME
6771	<	_ACEOF
7733	>	$as_echo "#define FC_FUNC_(name,NAME) NAME" >>confdefs.h
7734		;;
7735		"upper case, no underscore, extra underscore")
7736	<	cat >>confdefs.h <<\_ACEOF
6775	<	#define FC_FUNC(name,NAME) NAME
6776	<	_ACEOF
7736	>	$as_echo "#define FC_FUNC(name,NAME) NAME" >>confdefs.h
7737
7738	<	cat >>confdefs.h <<\_ACEOF
6779	<	#define FC_FUNC_(name,NAME) NAME ## _
6780	<	_ACEOF
7738	>	$as_echo "#define FC_FUNC_(name,NAME) NAME ## _" >>confdefs.h
7739		;;
7740		"upper case, underscore, no extra underscore")
7741	<	cat >>confdefs.h <<\_ACEOF
6784	<	#define FC_FUNC(name,NAME) NAME ## _
6785	<	_ACEOF
7741	>	$as_echo "#define FC_FUNC(name,NAME) NAME ## _" >>confdefs.h
7742
7743	<	cat >>confdefs.h <<\_ACEOF
6788	<	#define FC_FUNC_(name,NAME) NAME ## _
6789	<	_ACEOF
7743	>	$as_echo "#define FC_FUNC_(name,NAME) NAME ## _" >>confdefs.h
7744		;;
7745		"upper case, underscore, extra underscore")
7746	<	cat >>confdefs.h <<\_ACEOF
6793	<	#define FC_FUNC(name,NAME) NAME ## _
6794	<	_ACEOF
7746	>	$as_echo "#define FC_FUNC(name,NAME) NAME ## _" >>confdefs.h
7747
7748	<	cat >>confdefs.h <<\_ACEOF
6797	<	#define FC_FUNC_(name,NAME) NAME ## __
6798	<	_ACEOF
7748	>	$as_echo "#define FC_FUNC_(name,NAME) NAME ## __" >>confdefs.h
7749		;;
7750		*)
7751	<	{ $as_echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
7751	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unknown Fortran name-mangling scheme" >&5
7752		$as_echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
7753	<	;;
7753	>	;;
7754		esac
7755
7756		ac_ext=${ac_fc_srcext-f}
#	Line 6814 \| Line 7764 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7764		ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7765		ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7766		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7767	<	{ $as_echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
7767	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to get verbose linking output from $FC" >&5
7768		$as_echo_n "checking how to get verbose linking output from $FC... " >&6; }
7769	<	if test "${ac_cv_prog_fc_v+set}" = set; then
7769	>	if test "${ac_cv_prog_fc_v+set}" = set; then :
7770		$as_echo_n "(cached) " >&6
7771		else
7772	<	cat >conftest.$ac_ext <<_ACEOF
7772	>	cat > conftest.$ac_ext <<_ACEOF
7773		program main
7774
7775		end
7776		_ACEOF
7777	<	rm -f conftest.$ac_objext
6828	<	if { (ac_try="$ac_compile"
6829	<	case "(($ac_try" in
6830	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
6831	<	*) ac_try_echo=$ac_try;;
6832	<	esac
6833	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6834	<	$as_echo "$ac_try_echo") >&5
6835	<	(eval "$ac_compile") 2>conftest.er1
6836	<	ac_status=$?
6837	<	grep -v '^ *+' conftest.er1 >conftest.err
6838	<	rm -f conftest.er1
6839	<	cat conftest.err >&5
6840	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6841	<	(exit $ac_status); } && {
6842	<	test -z "$ac_fc_werror_flag" \|\|
6843	<	test ! -s conftest.err
6844	<	} && test -s conftest.$ac_objext; then
7777	>	if ac_fn_fc_try_compile "$LINENO"; then :
7778		ac_cv_prog_fc_v=
7779		# Try some options frequently used verbose output
7780		for ac_verb in -v -verbose --verbose -V -\#\#\#; do
7781	<	cat >conftest.$ac_ext <<_ACEOF
7781	>	cat > conftest.$ac_ext <<_ACEOF
7782		program main
7783
7784		end
#	Line 6855 \| Line 7788 \| _ACEOF
7788		# 1 to this macro) to the Fortran compiler in order to get
7789		# "verbose" output that we can then parse for the Fortran linker
7790		# flags.
7791	<	ac_save_FFLAGS=$FCFLAGS
7791	>	ac_save_FCFLAGS=$FCFLAGS
7792		FCFLAGS="$FCFLAGS $ac_verb"
7793		eval "set x $ac_link"
7794		shift
7795	<	$as_echo "$as_me:$LINENO: $*" >&5
7795	>	$as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7796		# gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7797		# LIBRARY_PATH; skip all such settings.
7798		ac_fc_v_output=`eval $ac_link 5>&1 2>&1 \|
7799		grep -v 'Driving:' \| grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7800		$as_echo "$ac_fc_v_output" >&5
7801	<	FCFLAGS=$ac_save_FFLAGS
7801	>	FCFLAGS=$ac_save_FCFLAGS
7802
7803		rm -rf conftest*
7804
#	Line 6894 \| Line 7827 \| case $ac_fc_v_output in
7827		# Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7828		-cmdline\ \| -ignore\ \| -def\ )
7829		ac_fc_v_output=`echo $ac_fc_v_output \| sed "\
7830	<	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7831	<	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7832	<	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7830	>	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7831	>	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7832	>	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7833
7834		# If we are using Cray Fortran then delete quotes.
7835		cft90)
#	Line 6907 \| Line 7840 \| esac
7840		# look for -l* and *.a constructs in the output
7841		for ac_arg in $ac_fc_v_output; do
7842		case $ac_arg in
7843	<	[\\/].a \| ?:[\\/].a \| -[lLRu]*)
7844	<	ac_cv_prog_fc_v=$ac_verb
7845	<	break 2 ;;
7843	>	[\\/].a \| ?:[\\/].a \| -[lLRu]*)
7844	>	ac_cv_prog_fc_v=$ac_verb
7845	>	break 2 ;;
7846		esac
7847		done
7848		done
7849		if test -z "$ac_cv_prog_fc_v"; then
7850	<	{ $as_echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
7850	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot determine how to obtain linking information from $FC" >&5
7851		$as_echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
7852		fi
7853		else
7854	<	$as_echo "$as_me: failed program was:" >&5
6922	<	sed 's/^/\| /' conftest.$ac_ext >&5
6923	<
6924	<	{ $as_echo "$as_me:$LINENO: WARNING: compilation failed" >&5
7854	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: compilation failed" >&5
7855		$as_echo "$as_me: WARNING: compilation failed" >&2;}
7856		fi
6927	–
7857		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7858
7859		fi
7860	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
7860	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_v" >&5
7861		$as_echo "$ac_cv_prog_fc_v" >&6; }
7862	<	{ $as_echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
7862	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran libraries of $FC" >&5
7863		$as_echo_n "checking for Fortran libraries of $FC... " >&6; }
7864	<	if test "${ac_cv_fc_libs+set}" = set; then
7864	>	if test "${ac_cv_fc_libs+set}" = set; then :
7865		$as_echo_n "(cached) " >&6
7866		else
7867		if test "x$FCLIBS" != "x"; then
7868		ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
7869		else
7870
7871	<	cat >conftest.$ac_ext <<_ACEOF
7871	>	cat > conftest.$ac_ext <<_ACEOF
7872		program main
7873
7874		end
#	Line 6949 \| Line 7878 \| _ACEOF
7878		# 1 to this macro) to the Fortran compiler in order to get
7879		# "verbose" output that we can then parse for the Fortran linker
7880		# flags.
7881	<	ac_save_FFLAGS=$FCFLAGS
7881	>	ac_save_FCFLAGS=$FCFLAGS
7882		FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
7883		eval "set x $ac_link"
7884		shift
7885	<	$as_echo "$as_me:$LINENO: $*" >&5
7885	>	$as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7886		# gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7887		# LIBRARY_PATH; skip all such settings.
7888		ac_fc_v_output=`eval $ac_link 5>&1 2>&1 \|
7889		grep -v 'Driving:' \| grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7890		$as_echo "$ac_fc_v_output" >&5
7891	<	FCFLAGS=$ac_save_FFLAGS
7891	>	FCFLAGS=$ac_save_FCFLAGS
7892
7893		rm -rf conftest*
7894
#	Line 6988 \| Line 7917 \| case $ac_fc_v_output in
7917		# Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7918		-cmdline\ \| -ignore\ \| -def\ )
7919		ac_fc_v_output=`echo $ac_fc_v_output \| sed "\
7920	<	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7921	<	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7922	<	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7920	>	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
7921	>	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
7922	>	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
7923
7924		# If we are using Cray Fortran then delete quotes.
7925		cft90)
#	Line 7009 \| Line 7938 \| while test $# != 1; do
7938		shift
7939		ac_arg=$1
7940		case $ac_arg in
7941	<	[\\/].a \| ?:[\\/].a)
7942	<	ac_exists=false
7941	>	[\\/].a \| ?:[\\/].a)
7942	>	ac_exists=false
7943		for ac_i in $ac_cv_fc_libs; do
7944		if test x"$ac_arg" = x"$ac_i"; then
7945		ac_exists=true
#	Line 7018 \| Line 7947 \| while test $# != 1; do
7947		fi
7948		done
7949
7950	<	if test x"$ac_exists" = xtrue; then
7951	<	:
7950	>	if test x"$ac_exists" = xtrue; then :
7951	>
7952		else
7953		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7954		fi
7955	<
7956	<	;;
7957	<	-bI:*)
7029	<	ac_exists=false
7955	>	;;
7956	>	-bI:*)
7957	>	ac_exists=false
7958		for ac_i in $ac_cv_fc_libs; do
7959		if test x"$ac_arg" = x"$ac_i"; then
7960		ac_exists=true
#	Line 7034 \| Line 7962 \| fi
7962		fi
7963		done
7964
7965	<	if test x"$ac_exists" = xtrue; then
7966	<	:
7965	>	if test x"$ac_exists" = xtrue; then :
7966	>
7967		else
7968		if test "$ac_compiler_gnu" = yes; then
7969		for ac_link_opt in $ac_arg; do
#	Line 7045 \| Line 7973 \| fi
7973		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7974		fi
7975		fi
7976	<
7977	<	;;
7978	<	# Ignore these flags.
7979	<	-lang* \| -lcrt.o \| -lc \| -lgcc \| -lSystem \| -libmil \| -LANG:=* \| -LIST:* \| -LNO:*)
7980	<	;;
7981	<	-lkernel32)
7982	<	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7983	<	;;
7984	<	-[LRuYz])
7985	<	# These flags, when seen by themselves, take an argument.
7986	<	# We remove the space between option and argument and re-iterate
7987	<	# unless we find an empty arg or a new option (starting with -)
7976	>	;;
7977	>	# Ignore these flags.
7978	>	-lang* \| -lcrt.o \| -lc \| -lgcc \| -lSystem \| -libmil \| -little \
7979	>	\|-LANG:=* \| -LIST:* \| -LNO:*)
7980	>	;;
7981	>	-lkernel32)
7982	>	test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7983	>	;;
7984	>	-[LRuYz])
7985	>	# These flags, when seen by themselves, take an argument.
7986	>	# We remove the space between option and argument and re-iterate
7987	>	# unless we find an empty arg or a new option (starting with -)
7988		case $2 in
7989		"" \| -*);;
7990		*)
#	Line 7065 \| Line 7993 \| fi
7993		set X $ac_arg "$@"
7994		;;
7995		esac
7996	<	;;
7997	<	-YP,*)
7998	<	for ac_j in `$as_echo "$ac_arg" \| sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7999	<	ac_exists=false
7996	>	;;
7997	>	-YP,*)
7998	>	for ac_j in `$as_echo "$ac_arg" \| sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7999	>	ac_exists=false
8000		for ac_i in $ac_cv_fc_libs; do
8001		if test x"$ac_j" = x"$ac_i"; then
8002		ac_exists=true
#	Line 7076 \| Line 8004 \| fi
8004		fi
8005		done
8006
8007	<	if test x"$ac_exists" = xtrue; then
8008	<	:
8007	>	if test x"$ac_exists" = xtrue; then :
8008	>
8009		else
8010		ac_arg="$ac_arg $ac_j"
8011	<	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
8011	>	ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
8012		fi
8013	<
8014	<	done
8015	<	;;
8016	<	-[lLR]*)
7089	<	ac_exists=false
8013	>	done
8014	>	;;
8015	>	-[lLR]*)
8016	>	ac_exists=false
8017		for ac_i in $ac_cv_fc_libs; do
8018		if test x"$ac_arg" = x"$ac_i"; then
8019		ac_exists=true
#	Line 7094 \| Line 8021 \| fi
8021		fi
8022		done
8023
8024	<	if test x"$ac_exists" = xtrue; then
8025	<	:
8024	>	if test x"$ac_exists" = xtrue; then :
8025	>
8026		else
8027		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
8028		fi
8029	<
7103	<	;;
8029	>	;;
8030		-zallextract*\| -zdefaultextract)
8031		ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
8032		;;
8033	<	# Ignore everything else.
8033	>	# Ignore everything else.
8034		esac
8035		done
8036		# restore positional arguments
#	Line 7116 \| Line 8042 \| case `(uname -sr) 2>/dev/null` in
8042		case `(uname -sr) 2>/dev/null` in
8043		"SunOS 5"*)
8044		ac_ld_run_path=`$as_echo "$ac_fc_v_output" \|
8045	<	sed -n 's,^.LD_RUN_PATH = $/[^ ]$.*$,-R\1,p'`
8045	>	sed -n 's,^.LD_RUN_PATH = $/[^ ]$.*$,-R\1,p'`
8046		test "x$ac_ld_run_path" != x &&
8047	<	if test "$ac_compiler_gnu" = yes; then
8047	>	if test "$ac_compiler_gnu" = yes; then
8048		for ac_link_opt in $ac_ld_run_path; do
8049		ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
8050		done
#	Line 7130 \| Line 8056 \| fi
8056		fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
8057
8058		fi
8059	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
8059	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_libs" >&5
8060		$as_echo "$ac_cv_fc_libs" >&6; }
8061		FCLIBS="$ac_cv_fc_libs"
8062
#	Line 7142 \| Line 8068 \| ac_compiler_gnu=$ac_cv_fc_compiler_gnu
8068
8069
8070
8071	<	{ $as_echo "$as_me:$LINENO: checking for module suffix" >&5
8071	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for module suffix" >&5
8072		$as_echo_n "checking for module suffix... " >&6; }
8073		rm -f conftest*
8074		# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
#	Line 7169 \| Line 8095 \| if (eval $ac_compile) 2>/dev/null ; then
8095		fi
8096		fi
8097		if test -z "$MOD" ; then
8098	<	{ $as_echo "$as_me:$LINENO: result: unknown" >&5
8098	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
8099		$as_echo "unknown" >&6; }
8100		# Use mod if we can't figure it out
8101		MOD="mod"
8102		else
8103	<	{ $as_echo "$as_me:$LINENO: result: $MOD" >&5
8103	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOD" >&5
8104		$as_echo "$MOD" >&6; }
8105		fi
8106		if test -s work.pcl ; then
8107	<	{ $as_echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
8107	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Compiler generates auxillery files!" >&5
8108		$as_echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
8109		fi
8110		else
8111	<	{ $as_echo "$as_me:$LINENO: result: unknown" >&5
8111	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
8112		$as_echo "unknown" >&6; }
8113		fi
8114
#	Line 7196 \| Line 8122 \| fi
8122		# specified, work.pcl and work.pc are created. However, if you specify
8123		# a file, it must contain a the name of a file ending in .pc . Ugh!
8124		# Use the module made above
8125	<	{ $as_echo "$as_me:$LINENO: checking for module directory path flag" >&5
8125	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for module directory path flag" >&5
8126		$as_echo_n "checking for module directory path flag... " >&6; }
8127		rm -f conftest*
8128		# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
#	Line 7230 \| Line 8156 \| EOF
8156		if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
8157		MODDIRFLAG="-I"
8158		F90MODINCSPEC="-I<dir>"
8159	<	{ $as_echo "$as_me:$LINENO: result: -I" >&5
8159	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: -I" >&5
8160		$as_echo "-I" >&6; }
8161		elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
8162		MODDIRFLAG="-M"
8163		F90MODINCSPEC="-M<dir>"
8164	<	{ $as_echo "$as_me:$LINENO: result: -M" >&5
8164	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: -M" >&5
8165		$as_echo "-M" >&6; }
8166		elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
8167		MODDIRFLAG="-p"
8168		F90MODINCSPEC="-p<dir>"
8169	<	{ $as_echo "$as_me:$LINENO: result: -p" >&5
8169	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: -p" >&5
8170		$as_echo "-p" >&6; }
8171		elif test -s work.pc ; then
8172		cp work.pc conf/mpimod.pc
#	Line 7248 \| Line 8174 \| $as_echo "-p" >&6; }
8174		echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
8175		if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
8176		MODDIRFLAG='-cl,mpimod.pcl'
8177	<	{ $as_echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
8177	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: -cl,filename where filename contains a list of files and directories" >&5
8178		$as_echo "-cl,filename where filename contains a list of files and directories" >&6; }
8179		F90_WORK_FILES_ARG="-cl,mpimod.pcl"
8180		F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
#	Line 7261 \| Line 8187 \| $as_echo "-cl,filename where filename contains a list
8187		fi
8188		fi
8189		if test -z "MODDIRFLAG" ; then
8190	<	{ $as_echo "$as_me:$LINENO: result: unknown" >&5
8190	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
8191		$as_echo "unknown" >&6; }
8192		fi
8193
#	Line 7271 \| Line 8197 \| fi
8197		fi
8198
8199
8200	<	{ $as_echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
8200	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran 90 module file names" >&5
8201		$as_echo_n "checking for Fortran 90 module file names... " >&6; }
8202	<	if test "${ac_cv_f90_module_names+set}" = set; then
8202	>	if test "${ac_cv_f90_module_names+set}" = set; then :
8203		$as_echo_n "(cached) " >&6
8204		else
8205		ac_ext=${ac_fc_srcext-f}
#	Line 7284 \| Line 8210 \| cd conftest
8210		# carry out the test in a new directory, so that we don't miss anything
8211		mkdir conftest
8212		cd conftest
8213	<	cat >conftest.$ac_ext <<_ACEOF
8213	>	cat > conftest.$ac_ext <<_ACEOF
8214		MODULE Bar
8215		END MODULE Bar
8216		_ACEOF
8217	<	rm -f conftest.$ac_objext
7292	<	if { (ac_try="$ac_compile"
7293	<	case "(($ac_try" in
7294	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
7295	<	*) ac_try_echo=$ac_try;;
7296	<	esac
7297	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7298	<	$as_echo "$ac_try_echo") >&5
7299	<	(eval "$ac_compile") 2>conftest.er1
7300	<	ac_status=$?
7301	<	grep -v '^ *+' conftest.er1 >conftest.err
7302	<	rm -f conftest.er1
7303	<	cat conftest.err >&5
7304	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7305	<	(exit $ac_status); } && {
7306	<	test -z "$ac_fc_werror_flag" \|\|
7307	<	test ! -s conftest.err
7308	<	} && test -s conftest.$ac_objext; then
8217	>	if ac_fn_fc_try_compile "$LINENO"; then :
8218		ac_cv_f90_module_names=
8219		ac_file_list=*
8220		for ac_file in $ac_file_list; do
#	Line 7325 \| Line 8234 \| for ac_file in $ac_file_list; do
8234		fi
8235		done
8236
8237	<	if test x"$ac_exists" = xtrue; then
8238	<	:
8237	>	if test x"$ac_exists" = xtrue; then :
8238	>
8239		else
8240		ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8241		fi
7333	–
8242		;;
8243		# look for new files derived from the module name,
8244		# with different case translation schemes
#	Line 7344 \| Line 8252 \| fi
8252		fi
8253		done
8254
8255	<	if test x"$ac_exists" = xtrue; then
8256	<	:
8255	>	if test x"$ac_exists" = xtrue; then :
8256	>
8257		else
8258		ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8259		fi
7352	–
8260		;;
8261		bar)
8262		ac_pat=`echo $ac_file \| sed s/bar/%module%/`
#	Line 7361 \| Line 8268 \| fi
8268		fi
8269		done
8270
8271	<	if test x"$ac_exists" = xtrue; then
8272	<	:
8271	>	if test x"$ac_exists" = xtrue; then :
8272	>
8273		else
8274		ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8275		fi
7369	–
8276		;;
8277		BAR)
8278		ac_pat=`echo $ac_file \| sed s/BAR/%MODULE%/`
#	Line 7378 \| Line 8284 \| fi
8284		fi
8285		done
8286
8287	<	if test x"$ac_exists" = xtrue; then
8288	<	:
8287	>	if test x"$ac_exists" = xtrue; then :
8288	>
8289		else
8290		ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8291		fi
7386	–
8292		;;
8293		# Other files - we have no idea how they are generated
8294		*)
8295	<	{ $as_echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
8295	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Bogus file found: $ac_file" >&5
8296		$as_echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
8297		;;
8298		esac
8299		done
8300		if test "x$ac_cv_f90_module_names" = "x"; then
8301	<	{ $as_echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
8301	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Couldn't determine module file names" >&5
8302		$as_echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
8303		fi
8304
8305		else
8306	<	$as_echo "$as_me: failed program was:" >&5
8307	<	sed 's/^/\| /' conftest.$ac_ext >&5
7403	<
7404	<	ac_cv_f90_module_names=
7405	<	{ $as_echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
8306	>	ac_cv_f90_module_names=
8307	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Couldn't determine module file names" >&5
8308		$as_echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
8309		fi
7408	–
8310		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8311		cd ..
8312		# cleanup
#	Line 7416 \| Line 8317 \| fi
8317		ac_compiler_gnu=$ac_cv_fc_compiler_gnu
8318
8319		fi
8320	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
8320	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_f90_module_names" >&5
8321		$as_echo "$ac_cv_f90_module_names" >&6; } # AC_CACHE_CHECK
8322
8323		# We now generate a shell script that will help us to figure out the correct
#	Line 7495 \| Line 8396 \| esac
8396		F90_MODULE_NAMES=unknown ;;
8397		esac
8398
8399	<	ac_ext=c
8400	<	ac_cpp='$CPP $CPPFLAGS'
8401	<	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8402	<	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7502	<	ac_compiler_gnu=$ac_cv_c_compiler_gnu
8399	>	ac_ext=${ac_fc_srcext-f}
8400	>	ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
8401	>	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
8402	>	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
8403
8404
8405		ac_ext=c
#	Line 7507 \| Line 8407 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
8407		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8408		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8409		ac_compiler_gnu=$ac_cv_c_compiler_gnu
7510	–
8410
8411
8412	<	{ $as_echo "$as_me:$LINENO: checking for asin in -lm" >&5
8412	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for asin in -lm" >&5
8413		$as_echo_n "checking for asin in -lm... " >&6; }
8414	<	if test "${ac_cv_lib_m_asin+set}" = set; then
8414	>	if test "${ac_cv_lib_m_asin+set}" = set; then :
8415		$as_echo_n "(cached) " >&6
8416		else
8417		ac_check_lib_save_LIBS=$LIBS
8418		LIBS="-lm $LIBS"
8419	<	cat >conftest.$ac_ext <<_ACEOF
7521	<	/* confdefs.h. */
7522	<	_ACEOF
7523	<	cat confdefs.h >>conftest.$ac_ext
7524	<	cat >>conftest.$ac_ext <<_ACEOF
8419	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8420		/* end confdefs.h. */
8421
8422		/* Override any GCC internal prototype to avoid an error.
#	Line 7547 \| Line 8442 \| _ACEOF
8442		return 0;
8443		}
8444		_ACEOF
8445	<	rm -f conftest.$ac_objext conftest$ac_exeext
7551	<	if { (ac_try="$ac_link"
7552	<	case "(($ac_try" in
7553	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
7554	<	*) ac_try_echo=$ac_try;;
7555	<	esac
7556	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7557	<	$as_echo "$ac_try_echo") >&5
7558	<	(eval "$ac_link") 2>conftest.er1
7559	<	ac_status=$?
7560	<	grep -v '^ *+' conftest.er1 >conftest.err
7561	<	rm -f conftest.er1
7562	<	cat conftest.err >&5
7563	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7564	<	(exit $ac_status); } && {
7565	<	test -z "$ac_c_werror_flag" \|\|
7566	<	test ! -s conftest.err
7567	<	} && test -s conftest$ac_exeext && {
7568	<	test "$cross_compiling" = yes \|\|
7569	<	$as_test_x conftest$ac_exeext
7570	<	}; then
8445	>	if ac_fn_c_try_link "$LINENO"; then :
8446		ac_cv_lib_m_asin=yes
8447		else
8448	<	$as_echo "$as_me: failed program was:" >&5
7574	<	sed 's/^/\| /' conftest.$ac_ext >&5
7575	<
7576	<	ac_cv_lib_m_asin=no
8448	>	ac_cv_lib_m_asin=no
8449		fi
8450	<
8451	<	rm -rf conftest.dSYM
7580	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7581	<	conftest$ac_exeext conftest.$ac_ext
8450	>	rm -f core conftest.err conftest.$ac_objext \
8451	>	conftest$ac_exeext conftest.$ac_ext
8452		LIBS=$ac_check_lib_save_LIBS
8453		fi
8454	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
8454	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_asin" >&5
8455		$as_echo "$ac_cv_lib_m_asin" >&6; }
8456	<	if test $ac_cv_lib_m_asin = yes; then
8456	>	if test "x$ac_cv_lib_m_asin" = x""yes; then :
8457		cat >>confdefs.h <<_ACEOF
8458		#define HAVE_LIBM 1
8459		_ACEOF
#	Line 7595 \| Line 8465 \| fi
8465		fi
8466
8467
8468	<	{ $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
8468	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
8469		$as_echo_n "checking for ANSI C header files... " >&6; }
8470	<	if test "${ac_cv_header_stdc+set}" = set; then
8470	>	if test "${ac_cv_header_stdc+set}" = set; then :
8471		$as_echo_n "(cached) " >&6
8472		else
8473	<	cat >conftest.$ac_ext <<_ACEOF
7604	<	/* confdefs.h. */
7605	<	_ACEOF
7606	<	cat confdefs.h >>conftest.$ac_ext
7607	<	cat >>conftest.$ac_ext <<_ACEOF
8473	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8474		/* end confdefs.h. */
8475		#include <stdlib.h>
8476		#include <stdarg.h>
#	Line 7627 \| Line 8493 \| _ACEOF
8493		return 0;
8494		}
8495		_ACEOF
8496	<	rm -f conftest.$ac_objext
7631	<	if { (ac_try="$ac_compile"
7632	<	case "(($ac_try" in
7633	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
7634	<	*) ac_try_echo=$ac_try;;
7635	<	esac
7636	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7637	<	$as_echo "$ac_try_echo") >&5
7638	<	(eval "$ac_compile") 2>conftest.er1
7639	<	ac_status=$?
7640	<	grep -v '^ *+' conftest.er1 >conftest.err
7641	<	rm -f conftest.er1
7642	<	cat conftest.err >&5
7643	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644	<	(exit $ac_status); } && {
7645	<	test -z "$ac_c_werror_flag" \|\|
7646	<	test ! -s conftest.err
7647	<	} && test -s conftest.$ac_objext; then
8496	>	if ac_fn_c_try_compile "$LINENO"; then :
8497		ac_cv_header_stdc=yes
8498		else
8499	<	$as_echo "$as_me: failed program was:" >&5
7651	<	sed 's/^/\| /' conftest.$ac_ext >&5
7652	<
7653	<	ac_cv_header_stdc=no
8499	>	ac_cv_header_stdc=no
8500		fi
7655	–
8501		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8502
8503		if test $ac_cv_header_stdc = yes; then
8504		# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
8505	<	cat >conftest.$ac_ext <<_ACEOF
7661	<	/* confdefs.h. */
7662	<	_ACEOF
7663	<	cat confdefs.h >>conftest.$ac_ext
7664	<	cat >>conftest.$ac_ext <<_ACEOF
8505	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8506		/* end confdefs.h. */
8507		#include <string.h>
8508
8509		_ACEOF
8510		if (eval "$ac_cpp conftest.$ac_ext") 2>&5 \|
8511	<	$EGREP "memchr" >/dev/null 2>&1; then
8512	<	:
8511	>	$EGREP "memchr" >/dev/null 2>&1; then :
8512	>
8513		else
8514		ac_cv_header_stdc=no
8515		fi
#	Line 7678 \| Line 8519 \| if test $ac_cv_header_stdc = yes; then
8519
8520		if test $ac_cv_header_stdc = yes; then
8521		# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
8522	<	cat >conftest.$ac_ext <<_ACEOF
7682	<	/* confdefs.h. */
7683	<	_ACEOF
7684	<	cat confdefs.h >>conftest.$ac_ext
7685	<	cat >>conftest.$ac_ext <<_ACEOF
8522	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8523		/* end confdefs.h. */
8524		#include <stdlib.h>
8525
8526		_ACEOF
8527		if (eval "$ac_cpp conftest.$ac_ext") 2>&5 \|
8528	<	$EGREP "free" >/dev/null 2>&1; then
8529	<	:
8528	>	$EGREP "free" >/dev/null 2>&1; then :
8529	>
8530		else
8531		ac_cv_header_stdc=no
8532		fi
#	Line 7699 \| Line 8536 \| if test $ac_cv_header_stdc = yes; then
8536
8537		if test $ac_cv_header_stdc = yes; then
8538		# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
8539	<	if test "$cross_compiling" = yes; then
8539	>	if test "$cross_compiling" = yes; then :
8540		:
8541		else
8542	<	cat >conftest.$ac_ext <<_ACEOF
7706	<	/* confdefs.h. */
7707	<	_ACEOF
7708	<	cat confdefs.h >>conftest.$ac_ext
7709	<	cat >>conftest.$ac_ext <<_ACEOF
8542	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8543		/* end confdefs.h. */
8544		#include <ctype.h>
8545		#include <stdlib.h>
#	Line 7733 \| Line 8566 \| _ACEOF
8566		return 0;
8567		}
8568		_ACEOF
8569	<	rm -f conftest$ac_exeext
7737	<	if { (ac_try="$ac_link"
7738	<	case "(($ac_try" in
7739	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
7740	<	*) ac_try_echo=$ac_try;;
7741	<	esac
7742	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7743	<	$as_echo "$ac_try_echo") >&5
7744	<	(eval "$ac_link") 2>&5
7745	<	ac_status=$?
7746	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7747	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7748	<	{ (case "(($ac_try" in
7749	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
7750	<	*) ac_try_echo=$ac_try;;
7751	<	esac
7752	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7753	<	$as_echo "$ac_try_echo") >&5
7754	<	(eval "$ac_try") 2>&5
7755	<	ac_status=$?
7756	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7757	<	(exit $ac_status); }; }; then
7758	<	:
7759	<	else
7760	<	$as_echo "$as_me: program exited with status $ac_status" >&5
7761	<	$as_echo "$as_me: failed program was:" >&5
7762	<	sed 's/^/\| /' conftest.$ac_ext >&5
8569	>	if ac_fn_c_try_run "$LINENO"; then :
8570
8571	<	( exit $ac_status )
8572	<	ac_cv_header_stdc=no
8571	>	else
8572	>	ac_cv_header_stdc=no
8573		fi
8574	<	rm -rf conftest.dSYM
8575	<	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8574	>	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \
8575	>	conftest.$ac_objext conftest.beam conftest.$ac_ext
8576		fi
8577
7771	–
8578		fi
8579		fi
8580	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
8580	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
8581		$as_echo "$ac_cv_header_stdc" >&6; }
8582		if test $ac_cv_header_stdc = yes; then
8583
8584	<	cat >>confdefs.h <<\_ACEOF
7779	<	#define STDC_HEADERS 1
7780	<	_ACEOF
8584	>	$as_echo "#define STDC_HEADERS 1" >>confdefs.h
8585
8586		fi
8587
8588		# On IRIX 5.3, sys/types and inttypes.h are conflicting.
7785	–
7786	–
7787	–
7788	–
7789	–
7790	–
7791	–
7792	–
7793	–
8589		for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
8590		inttypes.h stdint.h unistd.h
8591	<	do
8592	<	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
8593	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
8594	<	$as_echo_n "checking for $ac_header... " >&6; }
8595	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
8596	<	$as_echo_n "(cached) " >&6
7802	<	else
7803	<	cat >conftest.$ac_ext <<_ACEOF
7804	<	/* confdefs.h. */
7805	<	_ACEOF
7806	<	cat confdefs.h >>conftest.$ac_ext
7807	<	cat >>conftest.$ac_ext <<_ACEOF
7808	<	/* end confdefs.h. */
7809	<	$ac_includes_default
7810	<
7811	<	#include <$ac_header>
7812	<	_ACEOF
7813	<	rm -f conftest.$ac_objext
7814	<	if { (ac_try="$ac_compile"
7815	<	case "(($ac_try" in
7816	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
7817	<	*) ac_try_echo=$ac_try;;
7818	<	esac
7819	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7820	<	$as_echo "$ac_try_echo") >&5
7821	<	(eval "$ac_compile") 2>conftest.er1
7822	<	ac_status=$?
7823	<	grep -v '^ *+' conftest.er1 >conftest.err
7824	<	rm -f conftest.er1
7825	<	cat conftest.err >&5
7826	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7827	<	(exit $ac_status); } && {
7828	<	test -z "$ac_c_werror_flag" \|\|
7829	<	test ! -s conftest.err
7830	<	} && test -s conftest.$ac_objext; then
7831	<	eval "$as_ac_Header=yes"
7832	<	else
7833	<	$as_echo "$as_me: failed program was:" >&5
7834	<	sed 's/^/\| /' conftest.$ac_ext >&5
7835	<
7836	<	eval "$as_ac_Header=no"
7837	<	fi
7838	<
7839	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7840	<	fi
7841	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
7842	<	$as_echo "$as_val"'`
7843	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
7844	<	$as_echo "$ac_res" >&6; }
7845	<	if test `eval 'as_val=${'$as_ac_Header'}
7846	<	$as_echo "$as_val"'` = yes; then
8591	>	do :
8592	>	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
8593	>	ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
8594	>	"
8595	>	eval as_val=\$$as_ac_Header
8596	>	if test "x$as_val" = x""yes; then :
8597		cat >>confdefs.h <<_ACEOF
8598		#define `$as_echo "HAVE_$ac_header" \| $as_tr_cpp` 1
8599		_ACEOF
#	Line 7858 \| Line 8608 \| done
8608		#
8609
8610		# Check whether --with-zlib was given.
8611	<	if test "${with_zlib+set}" = set; then
8611	>	if test "${with_zlib+set}" = set; then :
8612		withval=$with_zlib; zlib_dir="$withval"
8613		else
8614		zlib_dir="not_set"
#	Line 7871 \| Line 8621 \| if test "$zlib_dir" != "not_set" ; then
8621		then
8622		ZLIB_HOME="$zlib_dir"
8623		else
8624	<	{ $as_echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
8624	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
8625		$as_echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
8626		ZLIB_HOME=/usr/local
8627		if test ! -f "${ZLIB_HOME}/include/zlib.h"
#	Line 7896 \| Line 8646 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
8646		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8647		ac_compiler_gnu=$ac_cv_c_compiler_gnu
8648
8649	<	{ $as_echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
8649	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for inflateEnd in -lz" >&5
8650		$as_echo_n "checking for inflateEnd in -lz... " >&6; }
8651	<	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
8651	>	if test "${ac_cv_lib_z_inflateEnd+set}" = set; then :
8652		$as_echo_n "(cached) " >&6
8653		else
8654		ac_check_lib_save_LIBS=$LIBS
8655		LIBS="-lz $LIBS"
8656	<	cat >conftest.$ac_ext <<_ACEOF
7907	<	/* confdefs.h. */
7908	<	_ACEOF
7909	<	cat confdefs.h >>conftest.$ac_ext
7910	<	cat >>conftest.$ac_ext <<_ACEOF
8656	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8657		/* end confdefs.h. */
8658
8659		/* Override any GCC internal prototype to avoid an error.
#	Line 7933 \| Line 8679 \| _ACEOF
8679		return 0;
8680		}
8681		_ACEOF
8682	<	rm -f conftest.$ac_objext conftest$ac_exeext
7937	<	if { (ac_try="$ac_link"
7938	<	case "(($ac_try" in
7939	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
7940	<	*) ac_try_echo=$ac_try;;
7941	<	esac
7942	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7943	<	$as_echo "$ac_try_echo") >&5
7944	<	(eval "$ac_link") 2>conftest.er1
7945	<	ac_status=$?
7946	<	grep -v '^ *+' conftest.er1 >conftest.err
7947	<	rm -f conftest.er1
7948	<	cat conftest.err >&5
7949	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7950	<	(exit $ac_status); } && {
7951	<	test -z "$ac_c_werror_flag" \|\|
7952	<	test ! -s conftest.err
7953	<	} && test -s conftest$ac_exeext && {
7954	<	test "$cross_compiling" = yes \|\|
7955	<	$as_test_x conftest$ac_exeext
7956	<	}; then
8682	>	if ac_fn_c_try_link "$LINENO"; then :
8683		ac_cv_lib_z_inflateEnd=yes
8684		else
8685	<	$as_echo "$as_me: failed program was:" >&5
7960	<	sed 's/^/\| /' conftest.$ac_ext >&5
7961	<
7962	<	ac_cv_lib_z_inflateEnd=no
8685	>	ac_cv_lib_z_inflateEnd=no
8686		fi
8687	<
8688	<	rm -rf conftest.dSYM
7966	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7967	<	conftest$ac_exeext conftest.$ac_ext
8687	>	rm -f core conftest.err conftest.$ac_objext \
8688	>	conftest$ac_exeext conftest.$ac_ext
8689		LIBS=$ac_check_lib_save_LIBS
8690		fi
8691	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
8691	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_inflateEnd" >&5
8692		$as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
8693	<	if test $ac_cv_lib_z_inflateEnd = yes; then
8693	>	if test "x$ac_cv_lib_z_inflateEnd" = x""yes; then :
8694		zlib_cv_libz=yes
8695		else
8696		zlib_cv_libz=no
8697		fi
8698
8699	<	if test "${ac_cv_header_zlib_h+set}" = set; then
8700	<	{ $as_echo "$as_me:$LINENO: checking for zlib.h" >&5
7980	<	$as_echo_n "checking for zlib.h... " >&6; }
7981	<	if test "${ac_cv_header_zlib_h+set}" = set; then
7982	<	$as_echo_n "(cached) " >&6
7983	<	fi
7984	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
7985	<	$as_echo "$ac_cv_header_zlib_h" >&6; }
7986	<	else
7987	<	# Is the header compilable?
7988	<	{ $as_echo "$as_me:$LINENO: checking zlib.h usability" >&5
7989	<	$as_echo_n "checking zlib.h usability... " >&6; }
7990	<	cat >conftest.$ac_ext <<_ACEOF
7991	<	/* confdefs.h. */
7992	<	_ACEOF
7993	<	cat confdefs.h >>conftest.$ac_ext
7994	<	cat >>conftest.$ac_ext <<_ACEOF
7995	<	/* end confdefs.h. */
7996	<	$ac_includes_default
7997	<	#include <zlib.h>
7998	<	_ACEOF
7999	<	rm -f conftest.$ac_objext
8000	<	if { (ac_try="$ac_compile"
8001	<	case "(($ac_try" in
8002	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8003	<	*) ac_try_echo=$ac_try;;
8004	<	esac
8005	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8006	<	$as_echo "$ac_try_echo") >&5
8007	<	(eval "$ac_compile") 2>conftest.er1
8008	<	ac_status=$?
8009	<	grep -v '^ *+' conftest.er1 >conftest.err
8010	<	rm -f conftest.er1
8011	<	cat conftest.err >&5
8012	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8013	<	(exit $ac_status); } && {
8014	<	test -z "$ac_c_werror_flag" \|\|
8015	<	test ! -s conftest.err
8016	<	} && test -s conftest.$ac_objext; then
8017	<	ac_header_compiler=yes
8018	<	else
8019	<	$as_echo "$as_me: failed program was:" >&5
8020	<	sed 's/^/\| /' conftest.$ac_ext >&5
8021	<
8022	<	ac_header_compiler=no
8023	<	fi
8024	<
8025	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8026	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8027	<	$as_echo "$ac_header_compiler" >&6; }
8028	<
8029	<	# Is the header present?
8030	<	{ $as_echo "$as_me:$LINENO: checking zlib.h presence" >&5
8031	<	$as_echo_n "checking zlib.h presence... " >&6; }
8032	<	cat >conftest.$ac_ext <<_ACEOF
8033	<	/* confdefs.h. */
8034	<	_ACEOF
8035	<	cat confdefs.h >>conftest.$ac_ext
8036	<	cat >>conftest.$ac_ext <<_ACEOF
8037	<	/* end confdefs.h. */
8038	<	#include <zlib.h>
8039	<	_ACEOF
8040	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
8041	<	case "(($ac_try" in
8042	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8043	<	*) ac_try_echo=$ac_try;;
8044	<	esac
8045	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8046	<	$as_echo "$ac_try_echo") >&5
8047	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8048	<	ac_status=$?
8049	<	grep -v '^ *+' conftest.er1 >conftest.err
8050	<	rm -f conftest.er1
8051	<	cat conftest.err >&5
8052	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8053	<	(exit $ac_status); } >/dev/null && {
8054	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
8055	<	test ! -s conftest.err
8056	<	}; then
8057	<	ac_header_preproc=yes
8058	<	else
8059	<	$as_echo "$as_me: failed program was:" >&5
8060	<	sed 's/^/\| /' conftest.$ac_ext >&5
8061	<
8062	<	ac_header_preproc=no
8063	<	fi
8064	<
8065	<	rm -f conftest.err conftest.$ac_ext
8066	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8067	<	$as_echo "$ac_header_preproc" >&6; }
8068	<
8069	<	# So? What about this header?
8070	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8071	<	yes:no: )
8072	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
8073	<	$as_echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8074	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
8075	<	$as_echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
8076	<	ac_header_preproc=yes
8077	<	;;
8078	<	no:yes:* )
8079	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
8080	<	$as_echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
8081	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: check for missing prerequisite headers?" >&5
8082	<	$as_echo "$as_me: WARNING: zlib.h: check for missing prerequisite headers?" >&2;}
8083	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
8084	<	$as_echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
8085	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: section \"Present But Cannot Be Compiled\"" >&5
8086	<	$as_echo "$as_me: WARNING: zlib.h: section \"Present But Cannot Be Compiled\"" >&2;}
8087	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
8088	<	$as_echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
8089	<	{ $as_echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
8090	<	$as_echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
8091	<	( cat <<\_ASBOX
8092	<	## ------------------------------ ##
8093	<	## Report this to gezelter@nd.edu ##
8094	<	## ------------------------------ ##
8095	<	_ASBOX
8096	<	) \| sed "s/^/$as_me: WARNING: /" >&2
8097	<	;;
8098	<	esac
8099	<	{ $as_echo "$as_me:$LINENO: checking for zlib.h" >&5
8100	<	$as_echo_n "checking for zlib.h... " >&6; }
8101	<	if test "${ac_cv_header_zlib_h+set}" = set; then
8102	<	$as_echo_n "(cached) " >&6
8103	<	else
8104	<	ac_cv_header_zlib_h=$ac_header_preproc
8105	<	fi
8106	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
8107	<	$as_echo "$ac_cv_header_zlib_h" >&6; }
8108	<
8109	<	fi
8110	<	if test $ac_cv_header_zlib_h = yes; then
8699	>	ac_fn_c_check_header_mongrel "$LINENO" "zlib.h" "ac_cv_header_zlib_h" "$ac_includes_default"
8700	>	if test "x$ac_cv_header_zlib_h" = x""yes; then :
8701		zlib_cv_zlib_h=yes
8702		else
8703		zlib_cv_zlib_h=no
#	Line 8123 \| Line 8713 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
8713
8714		if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
8715
8716	<	cat >>confdefs.h <<\_ACEOF
8127	<	#define HAVE_ZLIB_H 1
8128	<	_ACEOF
8716	>	$as_echo "#define HAVE_ZLIB_H 1" >>confdefs.h
8717
8718
8719	<	cat >>confdefs.h <<\_ACEOF
8132	<	#define HAVE_LIBZ 1
8133	<	_ACEOF
8719	>	$as_echo "#define HAVE_LIBZ 1" >>confdefs.h
8720
8721		ZLIB_INC_DIR="${ZLIB_HOME}/include"
8722		ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
8723		ZLIB="-lz"
8724		else
8725	<	{ $as_echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
8725	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking zlib in ${ZLIB_HOME}" >&5
8726		$as_echo_n "checking zlib in ${ZLIB_HOME}... " >&6; }
8727		ZLIB_INC_DIR=
8728		ZLIB_LIB_DIR=
8729		ZLIB=
8730		LDFLAGS="$ZLIB_OLD_LDFLAGS"
8731		CFLAGS="$ZLIB_OLD_CFLAGS"
8732	<	{ $as_echo "$as_me:$LINENO: result: failed" >&5
8732	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
8733		$as_echo "failed" >&6; }
8734		echo ""
8735		echo "*********************************************************"
#	Line 8167 \| Line 8753 \| fi
8753		#
8754
8755		# Check whether --with-fftw was given.
8756	<	if test "${with_fftw+set}" = set; then
8756	>	if test "${with_fftw+set}" = set; then :
8757		withval=$with_fftw; fftw_dir="$withval"
8758		else
8759		fftw_dir="not_set"
#	Line 8178 \| Line 8764 \| if test "$fftw_dir" != "no"; then
8764		if test -d "$fftw_dir"; then
8765		FFTW_HOME="$fftw_dir"
8766		else
8767	<	{ $as_echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
8767	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
8768		$as_echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
8769		FFTW_HOME=/usr/local
8770		if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o -f "${FFTW_HOME}/include/dfftw.h"; then
#	Line 8200 \| Line 8786 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
8786		ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8787		ac_compiler_gnu=$ac_cv_c_compiler_gnu
8788
8789	<	{ $as_echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
8789	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
8790		$as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
8791	<	if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
8791	>	if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then :
8792		$as_echo_n "(cached) " >&6
8793		else
8794		ac_check_lib_save_LIBS=$LIBS
8795		LIBS="-lfftw3 $LIBS"
8796	<	cat >conftest.$ac_ext <<_ACEOF
8211	<	/* confdefs.h. */
8212	<	_ACEOF
8213	<	cat confdefs.h >>conftest.$ac_ext
8214	<	cat >>conftest.$ac_ext <<_ACEOF
8796	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8797		/* end confdefs.h. */
8798
8799		/* Override any GCC internal prototype to avoid an error.
#	Line 8237 \| Line 8819 \| _ACEOF
8819		return 0;
8820		}
8821		_ACEOF
8822	<	rm -f conftest.$ac_objext conftest$ac_exeext
8823	<	if { (ac_try="$ac_link"
8242	<	case "(($ac_try" in
8243	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8244	<	*) ac_try_echo=$ac_try;;
8245	<	esac
8246	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8247	<	$as_echo "$ac_try_echo") >&5
8248	<	(eval "$ac_link") 2>conftest.er1
8249	<	ac_status=$?
8250	<	grep -v '^ *+' conftest.er1 >conftest.err
8251	<	rm -f conftest.er1
8252	<	cat conftest.err >&5
8253	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8254	<	(exit $ac_status); } && {
8255	<	test -z "$ac_c_werror_flag" \|\|
8256	<	test ! -s conftest.err
8257	<	} && test -s conftest$ac_exeext && {
8258	<	test "$cross_compiling" = yes \|\|
8259	<	$as_test_x conftest$ac_exeext
8260	<	}; then
8261	<	ac_cv_lib_fftw3_fftw_execute=yes
8262	<	else
8263	<	$as_echo "$as_me: failed program was:" >&5
8264	<	sed 's/^/\| /' conftest.$ac_ext >&5
8265	<
8266	<	ac_cv_lib_fftw3_fftw_execute=no
8267	<	fi
8268	<
8269	<	rm -rf conftest.dSYM
8270	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8271	<	conftest$ac_exeext conftest.$ac_ext
8272	<	LIBS=$ac_check_lib_save_LIBS
8273	<	fi
8274	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
8275	<	$as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
8276	<	if test $ac_cv_lib_fftw3_fftw_execute = yes; then
8277	<	fftw_cv_libfftw3=yes
8278	<	else
8279	<	fftw_cv_libfftw3=no
8280	<	fi
8281	<
8282	<	if test "${ac_cv_header_fftw3_h+set}" = set; then
8283	<	{ $as_echo "$as_me:$LINENO: checking for fftw3.h" >&5
8284	<	$as_echo_n "checking for fftw3.h... " >&6; }
8285	<	if test "${ac_cv_header_fftw3_h+set}" = set; then
8286	<	$as_echo_n "(cached) " >&6
8287	<	fi
8288	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8289	<	$as_echo "$ac_cv_header_fftw3_h" >&6; }
8290	<	else
8291	<	# Is the header compilable?
8292	<	{ $as_echo "$as_me:$LINENO: checking fftw3.h usability" >&5
8293	<	$as_echo_n "checking fftw3.h usability... " >&6; }
8294	<	cat >conftest.$ac_ext <<_ACEOF
8295	<	/* confdefs.h. */
8296	<	_ACEOF
8297	<	cat confdefs.h >>conftest.$ac_ext
8298	<	cat >>conftest.$ac_ext <<_ACEOF
8299	<	/* end confdefs.h. */
8300	<	$ac_includes_default
8301	<	#include <fftw3.h>
8302	<	_ACEOF
8303	<	rm -f conftest.$ac_objext
8304	<	if { (ac_try="$ac_compile"
8305	<	case "(($ac_try" in
8306	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8307	<	*) ac_try_echo=$ac_try;;
8308	<	esac
8309	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8310	<	$as_echo "$ac_try_echo") >&5
8311	<	(eval "$ac_compile") 2>conftest.er1
8312	<	ac_status=$?
8313	<	grep -v '^ *+' conftest.er1 >conftest.err
8314	<	rm -f conftest.er1
8315	<	cat conftest.err >&5
8316	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8317	<	(exit $ac_status); } && {
8318	<	test -z "$ac_c_werror_flag" \|\|
8319	<	test ! -s conftest.err
8320	<	} && test -s conftest.$ac_objext; then
8321	<	ac_header_compiler=yes
8822	>	if ac_fn_c_try_link "$LINENO"; then :
8823	>	ac_cv_lib_fftw3_fftw_execute=yes
8824		else
8825	<	$as_echo "$as_me: failed program was:" >&5
8324	<	sed 's/^/\| /' conftest.$ac_ext >&5
8325	<
8326	<	ac_header_compiler=no
8825	>	ac_cv_lib_fftw3_fftw_execute=no
8826		fi
8827	<
8828	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8829	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8331	<	$as_echo "$ac_header_compiler" >&6; }
8332	<
8333	<	# Is the header present?
8334	<	{ $as_echo "$as_me:$LINENO: checking fftw3.h presence" >&5
8335	<	$as_echo_n "checking fftw3.h presence... " >&6; }
8336	<	cat >conftest.$ac_ext <<_ACEOF
8337	<	/* confdefs.h. */
8338	<	_ACEOF
8339	<	cat confdefs.h >>conftest.$ac_ext
8340	<	cat >>conftest.$ac_ext <<_ACEOF
8341	<	/* end confdefs.h. */
8342	<	#include <fftw3.h>
8343	<	_ACEOF
8344	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
8345	<	case "(($ac_try" in
8346	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8347	<	*) ac_try_echo=$ac_try;;
8348	<	esac
8349	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8350	<	$as_echo "$ac_try_echo") >&5
8351	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8352	<	ac_status=$?
8353	<	grep -v '^ *+' conftest.er1 >conftest.err
8354	<	rm -f conftest.er1
8355	<	cat conftest.err >&5
8356	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8357	<	(exit $ac_status); } >/dev/null && {
8358	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
8359	<	test ! -s conftest.err
8360	<	}; then
8361	<	ac_header_preproc=yes
8362	<	else
8363	<	$as_echo "$as_me: failed program was:" >&5
8364	<	sed 's/^/\| /' conftest.$ac_ext >&5
8365	<
8366	<	ac_header_preproc=no
8827	>	rm -f core conftest.err conftest.$ac_objext \
8828	>	conftest$ac_exeext conftest.$ac_ext
8829	>	LIBS=$ac_check_lib_save_LIBS
8830		fi
8831	<
8832	<	rm -f conftest.err conftest.$ac_ext
8833	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8834	<	$as_echo "$ac_header_preproc" >&6; }
8372	<
8373	<	# So? What about this header?
8374	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8375	<	yes:no: )
8376	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
8377	<	$as_echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8378	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
8379	<	$as_echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
8380	<	ac_header_preproc=yes
8381	<	;;
8382	<	no:yes:* )
8383	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
8384	<	$as_echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
8385	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: check for missing prerequisite headers?" >&5
8386	<	$as_echo "$as_me: WARNING: fftw3.h: check for missing prerequisite headers?" >&2;}
8387	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
8388	<	$as_echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
8389	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: section \"Present But Cannot Be Compiled\"" >&5
8390	<	$as_echo "$as_me: WARNING: fftw3.h: section \"Present But Cannot Be Compiled\"" >&2;}
8391	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
8392	<	$as_echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
8393	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
8394	<	$as_echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
8395	<	( cat <<\_ASBOX
8396	<	## ------------------------------ ##
8397	<	## Report this to gezelter@nd.edu ##
8398	<	## ------------------------------ ##
8399	<	_ASBOX
8400	<	) \| sed "s/^/$as_me: WARNING: /" >&2
8401	<	;;
8402	<	esac
8403	<	{ $as_echo "$as_me:$LINENO: checking for fftw3.h" >&5
8404	<	$as_echo_n "checking for fftw3.h... " >&6; }
8405	<	if test "${ac_cv_header_fftw3_h+set}" = set; then
8406	<	$as_echo_n "(cached) " >&6
8831	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_execute" >&5
8832	>	$as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
8833	>	if test "x$ac_cv_lib_fftw3_fftw_execute" = x""yes; then :
8834	>	fftw_cv_libfftw3=yes
8835		else
8836	<	ac_cv_header_fftw3_h=$ac_header_preproc
8836	>	fftw_cv_libfftw3=no
8837		fi
8410	–	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8411	–	$as_echo "$ac_cv_header_fftw3_h" >&6; }
8838
8839	<	fi
8840	<	if test $ac_cv_header_fftw3_h = yes; then
8839	>	ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
8840	>	if test "x$ac_cv_header_fftw3_h" = x""yes; then :
8841		fftw_cv_fftw3_h=yes
8842		else
8843		fftw_cv_fftw3_h=no
#	Line 8419 \| Line 8845 \| fi
8845
8846
8847		if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
8848	<	{ $as_echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
8848	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -lfftw" >&5
8849		$as_echo_n "checking for fftwnd_one in -lfftw... " >&6; }
8850	<	if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
8850	>	if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then :
8851		$as_echo_n "(cached) " >&6
8852		else
8853		ac_check_lib_save_LIBS=$LIBS
8854		LIBS="-lfftw $LIBS"
8855	<	cat >conftest.$ac_ext <<_ACEOF
8430	<	/* confdefs.h. */
8431	<	_ACEOF
8432	<	cat confdefs.h >>conftest.$ac_ext
8433	<	cat >>conftest.$ac_ext <<_ACEOF
8855	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8856		/* end confdefs.h. */
8857
8858		/* Override any GCC internal prototype to avoid an error.
#	Line 8456 \| Line 8878 \| _ACEOF
8878		return 0;
8879		}
8880		_ACEOF
8881	<	rm -f conftest.$ac_objext conftest$ac_exeext
8460	<	if { (ac_try="$ac_link"
8461	<	case "(($ac_try" in
8462	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8463	<	*) ac_try_echo=$ac_try;;
8464	<	esac
8465	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8466	<	$as_echo "$ac_try_echo") >&5
8467	<	(eval "$ac_link") 2>conftest.er1
8468	<	ac_status=$?
8469	<	grep -v '^ *+' conftest.er1 >conftest.err
8470	<	rm -f conftest.er1
8471	<	cat conftest.err >&5
8472	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8473	<	(exit $ac_status); } && {
8474	<	test -z "$ac_c_werror_flag" \|\|
8475	<	test ! -s conftest.err
8476	<	} && test -s conftest$ac_exeext && {
8477	<	test "$cross_compiling" = yes \|\|
8478	<	$as_test_x conftest$ac_exeext
8479	<	}; then
8881	>	if ac_fn_c_try_link "$LINENO"; then :
8882		ac_cv_lib_fftw_fftwnd_one=yes
8883		else
8884	<	$as_echo "$as_me: failed program was:" >&5
8483	<	sed 's/^/\| /' conftest.$ac_ext >&5
8484	<
8485	<	ac_cv_lib_fftw_fftwnd_one=no
8884	>	ac_cv_lib_fftw_fftwnd_one=no
8885		fi
8886	<
8887	<	rm -rf conftest.dSYM
8489	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8490	<	conftest$ac_exeext conftest.$ac_ext
8886	>	rm -f core conftest.err conftest.$ac_objext \
8887	>	conftest$ac_exeext conftest.$ac_ext
8888		LIBS=$ac_check_lib_save_LIBS
8889		fi
8890	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
8890	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw_fftwnd_one" >&5
8891		$as_echo "$ac_cv_lib_fftw_fftwnd_one" >&6; }
8892	<	if test $ac_cv_lib_fftw_fftwnd_one = yes; then
8892	>	if test "x$ac_cv_lib_fftw_fftwnd_one" = x""yes; then :
8893		fftw_cv_libfftw=yes
8894		else
8895		fftw_cv_libfftw=no
8896		fi
8897
8898	<	if test "${ac_cv_header_fftw_h+set}" = set; then
8899	<	{ $as_echo "$as_me:$LINENO: checking for fftw.h" >&5
8503	<	$as_echo_n "checking for fftw.h... " >&6; }
8504	<	if test "${ac_cv_header_fftw_h+set}" = set; then
8505	<	$as_echo_n "(cached) " >&6
8506	<	fi
8507	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
8508	<	$as_echo "$ac_cv_header_fftw_h" >&6; }
8509	<	else
8510	<	# Is the header compilable?
8511	<	{ $as_echo "$as_me:$LINENO: checking fftw.h usability" >&5
8512	<	$as_echo_n "checking fftw.h usability... " >&6; }
8513	<	cat >conftest.$ac_ext <<_ACEOF
8514	<	/* confdefs.h. */
8515	<	_ACEOF
8516	<	cat confdefs.h >>conftest.$ac_ext
8517	<	cat >>conftest.$ac_ext <<_ACEOF
8518	<	/* end confdefs.h. */
8519	<	$ac_includes_default
8520	<	#include <fftw.h>
8521	<	_ACEOF
8522	<	rm -f conftest.$ac_objext
8523	<	if { (ac_try="$ac_compile"
8524	<	case "(($ac_try" in
8525	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8526	<	*) ac_try_echo=$ac_try;;
8527	<	esac
8528	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8529	<	$as_echo "$ac_try_echo") >&5
8530	<	(eval "$ac_compile") 2>conftest.er1
8531	<	ac_status=$?
8532	<	grep -v '^ *+' conftest.er1 >conftest.err
8533	<	rm -f conftest.er1
8534	<	cat conftest.err >&5
8535	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8536	<	(exit $ac_status); } && {
8537	<	test -z "$ac_c_werror_flag" \|\|
8538	<	test ! -s conftest.err
8539	<	} && test -s conftest.$ac_objext; then
8540	<	ac_header_compiler=yes
8541	<	else
8542	<	$as_echo "$as_me: failed program was:" >&5
8543	<	sed 's/^/\| /' conftest.$ac_ext >&5
8544	<
8545	<	ac_header_compiler=no
8546	<	fi
8547	<
8548	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8549	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8550	<	$as_echo "$ac_header_compiler" >&6; }
8551	<
8552	<	# Is the header present?
8553	<	{ $as_echo "$as_me:$LINENO: checking fftw.h presence" >&5
8554	<	$as_echo_n "checking fftw.h presence... " >&6; }
8555	<	cat >conftest.$ac_ext <<_ACEOF
8556	<	/* confdefs.h. */
8557	<	_ACEOF
8558	<	cat confdefs.h >>conftest.$ac_ext
8559	<	cat >>conftest.$ac_ext <<_ACEOF
8560	<	/* end confdefs.h. */
8561	<	#include <fftw.h>
8562	<	_ACEOF
8563	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
8564	<	case "(($ac_try" in
8565	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8566	<	*) ac_try_echo=$ac_try;;
8567	<	esac
8568	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8569	<	$as_echo "$ac_try_echo") >&5
8570	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8571	<	ac_status=$?
8572	<	grep -v '^ *+' conftest.er1 >conftest.err
8573	<	rm -f conftest.er1
8574	<	cat conftest.err >&5
8575	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8576	<	(exit $ac_status); } >/dev/null && {
8577	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
8578	<	test ! -s conftest.err
8579	<	}; then
8580	<	ac_header_preproc=yes
8581	<	else
8582	<	$as_echo "$as_me: failed program was:" >&5
8583	<	sed 's/^/\| /' conftest.$ac_ext >&5
8584	<
8585	<	ac_header_preproc=no
8586	<	fi
8587	<
8588	<	rm -f conftest.err conftest.$ac_ext
8589	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8590	<	$as_echo "$ac_header_preproc" >&6; }
8591	<
8592	<	# So? What about this header?
8593	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8594	<	yes:no: )
8595	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
8596	<	$as_echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8597	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
8598	<	$as_echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
8599	<	ac_header_preproc=yes
8600	<	;;
8601	<	no:yes:* )
8602	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
8603	<	$as_echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
8604	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: check for missing prerequisite headers?" >&5
8605	<	$as_echo "$as_me: WARNING: fftw.h: check for missing prerequisite headers?" >&2;}
8606	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
8607	<	$as_echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
8608	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: section \"Present But Cannot Be Compiled\"" >&5
8609	<	$as_echo "$as_me: WARNING: fftw.h: section \"Present But Cannot Be Compiled\"" >&2;}
8610	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
8611	<	$as_echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
8612	<	{ $as_echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
8613	<	$as_echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
8614	<	( cat <<\_ASBOX
8615	<	## ------------------------------ ##
8616	<	## Report this to gezelter@nd.edu ##
8617	<	## ------------------------------ ##
8618	<	_ASBOX
8619	<	) \| sed "s/^/$as_me: WARNING: /" >&2
8620	<	;;
8621	<	esac
8622	<	{ $as_echo "$as_me:$LINENO: checking for fftw.h" >&5
8623	<	$as_echo_n "checking for fftw.h... " >&6; }
8624	<	if test "${ac_cv_header_fftw_h+set}" = set; then
8625	<	$as_echo_n "(cached) " >&6
8626	<	else
8627	<	ac_cv_header_fftw_h=$ac_header_preproc
8628	<	fi
8629	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
8630	<	$as_echo "$ac_cv_header_fftw_h" >&6; }
8631	<
8632	<	fi
8633	<	if test $ac_cv_header_fftw_h = yes; then
8898	>	ac_fn_c_check_header_mongrel "$LINENO" "fftw.h" "ac_cv_header_fftw_h" "$ac_includes_default"
8899	>	if test "x$ac_cv_header_fftw_h" = x""yes; then :
8900		fftw_cv_fftw_h=yes
8901		else
8902		fftw_cv_fftw_h=no
#	Line 8638 \| Line 8904 \| fi
8904
8905
8906		if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
8907	<	{ $as_echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
8907	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -ldfftw" >&5
8908		$as_echo_n "checking for fftwnd_one in -ldfftw... " >&6; }
8909	<	if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
8909	>	if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then :
8910		$as_echo_n "(cached) " >&6
8911		else
8912		ac_check_lib_save_LIBS=$LIBS
8913		LIBS="-ldfftw $LIBS"
8914	<	cat >conftest.$ac_ext <<_ACEOF
8649	<	/* confdefs.h. */
8650	<	_ACEOF
8651	<	cat confdefs.h >>conftest.$ac_ext
8652	<	cat >>conftest.$ac_ext <<_ACEOF
8914	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8915		/* end confdefs.h. */
8916
8917		/* Override any GCC internal prototype to avoid an error.
#	Line 8675 \| Line 8937 \| _ACEOF
8937		return 0;
8938		}
8939		_ACEOF
8940	<	rm -f conftest.$ac_objext conftest$ac_exeext
8679	<	if { (ac_try="$ac_link"
8680	<	case "(($ac_try" in
8681	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8682	<	*) ac_try_echo=$ac_try;;
8683	<	esac
8684	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8685	<	$as_echo "$ac_try_echo") >&5
8686	<	(eval "$ac_link") 2>conftest.er1
8687	<	ac_status=$?
8688	<	grep -v '^ *+' conftest.er1 >conftest.err
8689	<	rm -f conftest.er1
8690	<	cat conftest.err >&5
8691	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8692	<	(exit $ac_status); } && {
8693	<	test -z "$ac_c_werror_flag" \|\|
8694	<	test ! -s conftest.err
8695	<	} && test -s conftest$ac_exeext && {
8696	<	test "$cross_compiling" = yes \|\|
8697	<	$as_test_x conftest$ac_exeext
8698	<	}; then
8940	>	if ac_fn_c_try_link "$LINENO"; then :
8941		ac_cv_lib_dfftw_fftwnd_one=yes
8942		else
8943	<	$as_echo "$as_me: failed program was:" >&5
8702	<	sed 's/^/\| /' conftest.$ac_ext >&5
8703	<
8704	<	ac_cv_lib_dfftw_fftwnd_one=no
8943	>	ac_cv_lib_dfftw_fftwnd_one=no
8944		fi
8945	<
8946	<	rm -rf conftest.dSYM
8708	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8709	<	conftest$ac_exeext conftest.$ac_ext
8945	>	rm -f core conftest.err conftest.$ac_objext \
8946	>	conftest$ac_exeext conftest.$ac_ext
8947		LIBS=$ac_check_lib_save_LIBS
8948		fi
8949	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
8949	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
8950		$as_echo "$ac_cv_lib_dfftw_fftwnd_one" >&6; }
8951	<	if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
8951	>	if test "x$ac_cv_lib_dfftw_fftwnd_one" = x""yes; then :
8952		fftw_cv_libdfftw=yes
8953		else
8954		fftw_cv_libdfftw=no
8718	–	fi
8719	–
8720	–	if test "${ac_cv_header_dfftw_h+set}" = set; then
8721	–	{ $as_echo "$as_me:$LINENO: checking for dfftw.h" >&5
8722	–	$as_echo_n "checking for dfftw.h... " >&6; }
8723	–	if test "${ac_cv_header_dfftw_h+set}" = set; then
8724	–	$as_echo_n "(cached) " >&6
8725	–	fi
8726	–	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
8727	–	$as_echo "$ac_cv_header_dfftw_h" >&6; }
8728	–	else
8729	–	# Is the header compilable?
8730	–	{ $as_echo "$as_me:$LINENO: checking dfftw.h usability" >&5
8731	–	$as_echo_n "checking dfftw.h usability... " >&6; }
8732	–	cat >conftest.$ac_ext <<_ACEOF
8733	–	/* confdefs.h. */
8734	–	_ACEOF
8735	–	cat confdefs.h >>conftest.$ac_ext
8736	–	cat >>conftest.$ac_ext <<_ACEOF
8737	–	/* end confdefs.h. */
8738	–	$ac_includes_default
8739	–	#include <dfftw.h>
8740	–	_ACEOF
8741	–	rm -f conftest.$ac_objext
8742	–	if { (ac_try="$ac_compile"
8743	–	case "(($ac_try" in
8744	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8745	–	*) ac_try_echo=$ac_try;;
8746	–	esac
8747	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8748	–	$as_echo "$ac_try_echo") >&5
8749	–	(eval "$ac_compile") 2>conftest.er1
8750	–	ac_status=$?
8751	–	grep -v '^ *+' conftest.er1 >conftest.err
8752	–	rm -f conftest.er1
8753	–	cat conftest.err >&5
8754	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8755	–	(exit $ac_status); } && {
8756	–	test -z "$ac_c_werror_flag" \|\|
8757	–	test ! -s conftest.err
8758	–	} && test -s conftest.$ac_objext; then
8759	–	ac_header_compiler=yes
8760	–	else
8761	–	$as_echo "$as_me: failed program was:" >&5
8762	–	sed 's/^/\| /' conftest.$ac_ext >&5
8763	–
8764	–	ac_header_compiler=no
8765	–	fi
8766	–
8767	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8768	–	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8769	–	$as_echo "$ac_header_compiler" >&6; }
8770	–
8771	–	# Is the header present?
8772	–	{ $as_echo "$as_me:$LINENO: checking dfftw.h presence" >&5
8773	–	$as_echo_n "checking dfftw.h presence... " >&6; }
8774	–	cat >conftest.$ac_ext <<_ACEOF
8775	–	/* confdefs.h. */
8776	–	_ACEOF
8777	–	cat confdefs.h >>conftest.$ac_ext
8778	–	cat >>conftest.$ac_ext <<_ACEOF
8779	–	/* end confdefs.h. */
8780	–	#include <dfftw.h>
8781	–	_ACEOF
8782	–	if { (ac_try="$ac_cpp conftest.$ac_ext"
8783	–	case "(($ac_try" in
8784	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8785	–	*) ac_try_echo=$ac_try;;
8786	–	esac
8787	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8788	–	$as_echo "$ac_try_echo") >&5
8789	–	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8790	–	ac_status=$?
8791	–	grep -v '^ *+' conftest.er1 >conftest.err
8792	–	rm -f conftest.er1
8793	–	cat conftest.err >&5
8794	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8795	–	(exit $ac_status); } >/dev/null && {
8796	–	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
8797	–	test ! -s conftest.err
8798	–	}; then
8799	–	ac_header_preproc=yes
8800	–	else
8801	–	$as_echo "$as_me: failed program was:" >&5
8802	–	sed 's/^/\| /' conftest.$ac_ext >&5
8803	–
8804	–	ac_header_preproc=no
8955		fi
8956
8957	<	rm -f conftest.err conftest.$ac_ext
8958	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8809	<	$as_echo "$ac_header_preproc" >&6; }
8810	<
8811	<	# So? What about this header?
8812	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8813	<	yes:no: )
8814	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
8815	<	$as_echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8816	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
8817	<	$as_echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
8818	<	ac_header_preproc=yes
8819	<	;;
8820	<	no:yes:* )
8821	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
8822	<	$as_echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
8823	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: check for missing prerequisite headers?" >&5
8824	<	$as_echo "$as_me: WARNING: dfftw.h: check for missing prerequisite headers?" >&2;}
8825	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
8826	<	$as_echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
8827	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: section \"Present But Cannot Be Compiled\"" >&5
8828	<	$as_echo "$as_me: WARNING: dfftw.h: section \"Present But Cannot Be Compiled\"" >&2;}
8829	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
8830	<	$as_echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
8831	<	{ $as_echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
8832	<	$as_echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
8833	<	( cat <<\_ASBOX
8834	<	## ------------------------------ ##
8835	<	## Report this to gezelter@nd.edu ##
8836	<	## ------------------------------ ##
8837	<	_ASBOX
8838	<	) \| sed "s/^/$as_me: WARNING: /" >&2
8839	<	;;
8840	<	esac
8841	<	{ $as_echo "$as_me:$LINENO: checking for dfftw.h" >&5
8842	<	$as_echo_n "checking for dfftw.h... " >&6; }
8843	<	if test "${ac_cv_header_dfftw_h+set}" = set; then
8844	<	$as_echo_n "(cached) " >&6
8845	<	else
8846	<	ac_cv_header_dfftw_h=$ac_header_preproc
8847	<	fi
8848	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
8849	<	$as_echo "$ac_cv_header_dfftw_h" >&6; }
8850	<
8851	<	fi
8852	<	if test $ac_cv_header_dfftw_h = yes; then
8957	>	ac_fn_c_check_header_mongrel "$LINENO" "dfftw.h" "ac_cv_header_dfftw_h" "$ac_includes_default"
8958	>	if test "x$ac_cv_header_dfftw_h" = x""yes; then :
8959		fftw_cv_dfftw_h=yes
8960		else
8961		fftw_cv_dfftw_h=no
#	Line 8866 \| Line 8972 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
8972
8973		if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
8974
8975	<	cat >>confdefs.h <<\_ACEOF
8870	<	#define HAVE_FFTW3_H 1
8871	<	_ACEOF
8975	>	$as_echo "#define HAVE_FFTW3_H 1" >>confdefs.h
8976
8977		FFTW_INC_DIR="${FFTW_HOME}/include"
8978		FFTW_LIB_DIR="${FFTW_HOME}/lib"
#	Line 8876 \| Line 8980 \| _ACEOF
8980		else
8981		if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
8982
8983	<	cat >>confdefs.h <<\_ACEOF
8880	<	#define HAVE_FFTW_H 1
8881	<	_ACEOF
8983	>	$as_echo "#define HAVE_FFTW_H 1" >>confdefs.h
8984
8985		FFTW_INC_DIR="${FFTW_HOME}/include"
8986		FFTW_LIB_DIR="${FFTW_HOME}/lib"
#	Line 8886 \| Line 8988 \| _ACEOF
8988		else
8989		if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
8990
8991	<	cat >>confdefs.h <<\_ACEOF
8890	<	#define HAVE_DFFTW_H 1
8891	<	_ACEOF
8991	>	$as_echo "#define HAVE_DFFTW_H 1" >>confdefs.h
8992
8993		FFTW_INC_DIR="${FFTW_HOME}/include"
8994		FFTW_LIB_DIR="${FFTW_HOME}/lib"
8995		FFTW_LIBS="-ldfftw"
8996		else
8997	<	{ $as_echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
8997	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking fftw in ${FFTW_HOME}" >&5
8998		$as_echo_n "checking fftw in ${FFTW_HOME}... " >&6; }
8999		FFTW_INC_DIR=
9000		FFTW_LIB_DIR=
9001		FFTW_LIBS=
9002		LDFLAGS="$FFTW_OLD_LDFLAGS"
9003		CFLAGS="$FFTW_OLD_CFLAGS"
9004	<	{ $as_echo "$as_me:$LINENO: result: failed" >&5
9004	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
9005		$as_echo "failed" >&6; }
9006		echo ""
9007		echo "*********************************************************"
#	Line 8928 \| Line 9028 \| fi
9028		#
9029
9030		# Check whether --with-qhull was given.
9031	<	if test "${with_qhull+set}" = set; then
9031	>	if test "${with_qhull+set}" = set; then :
9032		withval=$with_qhull; qhull_dir="$withval"
9033		else
9034		qhull_dir="not_set"
#	Line 8944 \| Line 9044 \| if test "$qhull_dir" != "no"; then
9044		if test -d "$qhull_dir"; then
9045		QHULL_HOME="$qhull_dir"
9046		else
9047	<	{ $as_echo "$as_me:$LINENO: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
9047	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
9048		$as_echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
9049		QHULL_HOME=/usr/local
9050		if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"; then
#	Line 8956 \| Line 9056 \| $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not
9056		# Locate qhull, if wanted
9057		#
9058		if test -n "${QHULL_HOME}"; then
9059	<	{ $as_echo "$as_me:$LINENO: Checking for qhull in ${QHULL_HOME}" >&5
9059	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: Checking for qhull in ${QHULL_HOME}" >&5
9060		$as_echo "$as_me: Checking for qhull in ${QHULL_HOME}" >&6;}
9061
9062		ac_ext=c
#	Line 8971 \| Line 9071 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
9071		LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
9072		CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
9073		CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
9074	<	if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
9075	<	{ $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
8976	<	$as_echo_n "checking for qhull/qhull.h... " >&6; }
8977	<	if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8978	<	$as_echo_n "(cached) " >&6
8979	<	fi
8980	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
8981	<	$as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
8982	<	else
8983	<	# Is the header compilable?
8984	<	{ $as_echo "$as_me:$LINENO: checking qhull/qhull.h usability" >&5
8985	<	$as_echo_n "checking qhull/qhull.h usability... " >&6; }
8986	<	cat >conftest.$ac_ext <<_ACEOF
8987	<	/* confdefs.h. */
8988	<	_ACEOF
8989	<	cat confdefs.h >>conftest.$ac_ext
8990	<	cat >>conftest.$ac_ext <<_ACEOF
8991	<	/* end confdefs.h. */
8992	<	$ac_includes_default
8993	<	#include <qhull/qhull.h>
8994	<	_ACEOF
8995	<	rm -f conftest.$ac_objext
8996	<	if { (ac_try="$ac_compile"
8997	<	case "(($ac_try" in
8998	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
8999	<	*) ac_try_echo=$ac_try;;
9000	<	esac
9001	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9002	<	$as_echo "$ac_try_echo") >&5
9003	<	(eval "$ac_compile") 2>conftest.er1
9004	<	ac_status=$?
9005	<	grep -v '^ *+' conftest.er1 >conftest.err
9006	<	rm -f conftest.er1
9007	<	cat conftest.err >&5
9008	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009	<	(exit $ac_status); } && {
9010	<	test -z "$ac_c_werror_flag" \|\|
9011	<	test ! -s conftest.err
9012	<	} && test -s conftest.$ac_objext; then
9013	<	ac_header_compiler=yes
9014	<	else
9015	<	$as_echo "$as_me: failed program was:" >&5
9016	<	sed 's/^/\| /' conftest.$ac_ext >&5
9017	<
9018	<	ac_header_compiler=no
9019	<	fi
9020	<
9021	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9022	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9023	<	$as_echo "$ac_header_compiler" >&6; }
9024	<
9025	<	# Is the header present?
9026	<	{ $as_echo "$as_me:$LINENO: checking qhull/qhull.h presence" >&5
9027	<	$as_echo_n "checking qhull/qhull.h presence... " >&6; }
9028	<	cat >conftest.$ac_ext <<_ACEOF
9029	<	/* confdefs.h. */
9030	<	_ACEOF
9031	<	cat confdefs.h >>conftest.$ac_ext
9032	<	cat >>conftest.$ac_ext <<_ACEOF
9033	<	/* end confdefs.h. */
9034	<	#include <qhull/qhull.h>
9035	<	_ACEOF
9036	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
9037	<	case "(($ac_try" in
9038	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9039	<	*) ac_try_echo=$ac_try;;
9040	<	esac
9041	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9042	<	$as_echo "$ac_try_echo") >&5
9043	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9044	<	ac_status=$?
9045	<	grep -v '^ *+' conftest.er1 >conftest.err
9046	<	rm -f conftest.er1
9047	<	cat conftest.err >&5
9048	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9049	<	(exit $ac_status); } >/dev/null && {
9050	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
9051	<	test ! -s conftest.err
9052	<	}; then
9053	<	ac_header_preproc=yes
9054	<	else
9055	<	$as_echo "$as_me: failed program was:" >&5
9056	<	sed 's/^/\| /' conftest.$ac_ext >&5
9057	<
9058	<	ac_header_preproc=no
9059	<	fi
9060	<
9061	<	rm -f conftest.err conftest.$ac_ext
9062	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9063	<	$as_echo "$ac_header_preproc" >&6; }
9064	<
9065	<	# So? What about this header?
9066	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9067	<	yes:no: )
9068	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&5
9069	<	$as_echo "$as_me: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9070	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&5
9071	<	$as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&2;}
9072	<	ac_header_preproc=yes
9073	<	;;
9074	<	no:yes:* )
9075	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: present but cannot be compiled" >&5
9076	<	$as_echo "$as_me: WARNING: qhull/qhull.h: present but cannot be compiled" >&2;}
9077	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: check for missing prerequisite headers?" >&5
9078	<	$as_echo "$as_me: WARNING: qhull/qhull.h: check for missing prerequisite headers?" >&2;}
9079	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: see the Autoconf documentation" >&5
9080	<	$as_echo "$as_me: WARNING: qhull/qhull.h: see the Autoconf documentation" >&2;}
9081	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: section \"Present But Cannot Be Compiled\"" >&5
9082	<	$as_echo "$as_me: WARNING: qhull/qhull.h: section \"Present But Cannot Be Compiled\"" >&2;}
9083	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&5
9084	<	$as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&2;}
9085	<	{ $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&5
9086	<	$as_echo "$as_me: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&2;}
9087	<	( cat <<\_ASBOX
9088	<	## ------------------------------ ##
9089	<	## Report this to gezelter@nd.edu ##
9090	<	## ------------------------------ ##
9091	<	_ASBOX
9092	<	) \| sed "s/^/$as_me: WARNING: /" >&2
9093	<	;;
9094	<	esac
9095	<	{ $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
9096	<	$as_echo_n "checking for qhull/qhull.h... " >&6; }
9097	<	if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
9098	<	$as_echo_n "(cached) " >&6
9099	<	else
9100	<	ac_cv_header_qhull_qhull_h=$ac_header_preproc
9101	<	fi
9102	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
9103	<	$as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
9104	<
9105	<	fi
9106	<	if test $ac_cv_header_qhull_qhull_h = yes; then
9074	>	ac_fn_c_check_header_mongrel "$LINENO" "qhull/qhull.h" "ac_cv_header_qhull_qhull_h" "$ac_includes_default"
9075	>	if test "x$ac_cv_header_qhull_qhull_h" = x""yes; then :
9076		qhull_cv_qhull_h=yes
9077		else
9078		qhull_cv_qhull_h=no
9079		fi
9080
9081
9082	<	{ $as_echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
9082	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull" >&5
9083		$as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
9084	<	if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
9084	>	if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then :
9085		$as_echo_n "(cached) " >&6
9086		else
9087		ac_check_lib_save_LIBS=$LIBS
9088		LIBS="-lqhull $LIBS"
9089	<	cat >conftest.$ac_ext <<_ACEOF
9121	<	/* confdefs.h. */
9122	<	_ACEOF
9123	<	cat confdefs.h >>conftest.$ac_ext
9124	<	cat >>conftest.$ac_ext <<_ACEOF
9089	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9090		/* end confdefs.h. */
9091
9092		/* Override any GCC internal prototype to avoid an error.
#	Line 9147 \| Line 9112 \| _ACEOF
9112		return 0;
9113		}
9114		_ACEOF
9115	<	rm -f conftest.$ac_objext conftest$ac_exeext
9151	<	if { (ac_try="$ac_link"
9152	<	case "(($ac_try" in
9153	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9154	<	*) ac_try_echo=$ac_try;;
9155	<	esac
9156	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9157	<	$as_echo "$ac_try_echo") >&5
9158	<	(eval "$ac_link") 2>conftest.er1
9159	<	ac_status=$?
9160	<	grep -v '^ *+' conftest.er1 >conftest.err
9161	<	rm -f conftest.er1
9162	<	cat conftest.err >&5
9163	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9164	<	(exit $ac_status); } && {
9165	<	test -z "$ac_c_werror_flag" \|\|
9166	<	test ! -s conftest.err
9167	<	} && test -s conftest$ac_exeext && {
9168	<	test "$cross_compiling" = yes \|\|
9169	<	$as_test_x conftest$ac_exeext
9170	<	}; then
9115	>	if ac_fn_c_try_link "$LINENO"; then :
9116		ac_cv_lib_qhull_qh_qhull=yes
9117		else
9118	<	$as_echo "$as_me: failed program was:" >&5
9174	<	sed 's/^/\| /' conftest.$ac_ext >&5
9175	<
9176	<	ac_cv_lib_qhull_qh_qhull=no
9118	>	ac_cv_lib_qhull_qh_qhull=no
9119		fi
9120	<
9121	<	rm -rf conftest.dSYM
9180	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9181	<	conftest$ac_exeext conftest.$ac_ext
9120	>	rm -f core conftest.err conftest.$ac_objext \
9121	>	conftest$ac_exeext conftest.$ac_ext
9122		LIBS=$ac_check_lib_save_LIBS
9123		fi
9124	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
9124	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull_qh_qhull" >&5
9125		$as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
9126	<	if test $ac_cv_lib_qhull_qh_qhull = yes; then
9126	>	if test "x$ac_cv_lib_qhull_qh_qhull" = x""yes; then :
9127		qhull_cv_libqhull=yes
9128		else
9129		qhull_cv_libqhull=no
#	Line 9201 \| Line 9141 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
9141
9142		if test "$qhull_cv_libqhull" = "yes" -a "$qhull_cv_qhull_h" = "yes"; then
9143
9144	<	cat >>confdefs.h <<\_ACEOF
9205	<	#define HAVE_QHULL_H 1
9206	<	_ACEOF
9144	>	$as_echo "#define HAVE_QHULL_H 1" >>confdefs.h
9145
9146
9147	<	cat >>confdefs.h <<\_ACEOF
9210	<	#define HAVE_QHULL 1
9211	<	_ACEOF
9147	>	$as_echo "#define HAVE_QHULL 1" >>confdefs.h
9148
9149		USE_QHULL=yes
9150		QHULL_INC_DIR="${QHULL_HOME}/include"
9151		QHULL_LIB_DIR="${QHULL_HOME}/lib"
9152		QHULL="-lqhull"
9153	<	{ $as_echo "$as_me:$LINENO: result: Working qhull found, will proceed." >&5
9153	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Working qhull found, will proceed." >&5
9154		$as_echo "Working qhull found, will proceed." >&6; }
9155		else
9156	<	{ $as_echo "$as_me:$LINENO: WARNING: " >&5
9156	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
9157		$as_echo "$as_me: WARNING: " >&2;}
9158	<	{ $as_echo "$as_me:$LINENO: WARNING: Could not find a working qhull installation" >&5
9158	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not find a working qhull installation" >&5
9159		$as_echo "$as_me: WARNING: Could not find a working qhull installation" >&2;}
9160	<	{ $as_echo "$as_me:$LINENO: WARNING: If you need OOPSE to be able to deal with convex " >&5
9160	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OOPSE to be able to deal with convex " >&5
9161		$as_echo "$as_me: WARNING: If you need OOPSE to be able to deal with convex " >&2;}
9162	<	{ $as_echo "$as_me:$LINENO: WARNING: hulls be sure to specify a valid qhull installation " >&5
9162	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: hulls be sure to specify a valid qhull installation " >&5
9163		$as_echo "$as_me: WARNING: hulls be sure to specify a valid qhull installation " >&2;}
9164	<	{ $as_echo "$as_me:$LINENO: WARNING: with --with-qhull=DIR " >&5
9164	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: with --with-qhull=DIR " >&5
9165		$as_echo "$as_me: WARNING: with --with-qhull=DIR " >&2;}
9166	<	{ $as_echo "$as_me:$LINENO: WARNING: " >&5
9166	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
9167		$as_echo "$as_me: WARNING: " >&2;}
9168	<	{ $as_echo "$as_me:$LINENO: WARNING: OOPSE will still work without qhull installed. " >&5
9168	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OOPSE will still work without qhull installed. " >&5
9169		$as_echo "$as_me: WARNING: OOPSE will still work without qhull installed. " >&2;}
9170	<	{ $as_echo "$as_me:$LINENO: WARNING: " >&5
9170	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
9171		$as_echo "$as_me: WARNING: " >&2;}
9172		fi
9173		fi
#	Line 9241 \| Line 9177 \| fi
9177
9178
9179
9244	–
9180		ac_ext=cpp
9181		ac_cpp='$CXXCPP $CPPFLAGS'
9182		ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9183		ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9184		ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9185	<	{ $as_echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
9185	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
9186		$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
9187		if test -z "$CXXCPP"; then
9188	<	if test "${ac_cv_prog_CXXCPP+set}" = set; then
9188	>	if test "${ac_cv_prog_CXXCPP+set}" = set; then :
9189		$as_echo_n "(cached) " >&6
9190		else
9191		# Double quotes because CXXCPP needs to be expanded
#	Line 9265 \| Line 9200 \| do
9200		# <limits.h> exists even on freestanding compilers.
9201		# On the NeXT, cc -E runs the code through the compiler's parser,
9202		# not just through cpp. "Syntax error" is here to catch this case.
9203	<	cat >conftest.$ac_ext <<_ACEOF
9269	<	/* confdefs.h. */
9270	<	_ACEOF
9271	<	cat confdefs.h >>conftest.$ac_ext
9272	<	cat >>conftest.$ac_ext <<_ACEOF
9203	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9204		/* end confdefs.h. */
9205		#ifdef __STDC__
9206		# include <limits.h>
#	Line 9278 \| Line 9209 \| _ACEOF
9209		#endif
9210		Syntax error
9211		_ACEOF
9212	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
9282	<	case "(($ac_try" in
9283	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9284	<	*) ac_try_echo=$ac_try;;
9285	<	esac
9286	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9287	<	$as_echo "$ac_try_echo") >&5
9288	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9289	<	ac_status=$?
9290	<	grep -v '^ *+' conftest.er1 >conftest.err
9291	<	rm -f conftest.er1
9292	<	cat conftest.err >&5
9293	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9294	<	(exit $ac_status); } >/dev/null && {
9295	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" \|\|
9296	<	test ! -s conftest.err
9297	<	}; then
9298	<	:
9299	<	else
9300	<	$as_echo "$as_me: failed program was:" >&5
9301	<	sed 's/^/\| /' conftest.$ac_ext >&5
9212	>	if ac_fn_cxx_try_cpp "$LINENO"; then :
9213
9214	+	else
9215		# Broken: fails on valid input.
9216		continue
9217		fi
9306	–
9218		rm -f conftest.err conftest.$ac_ext
9219
9220		# OK, works on sane cases. Now check whether nonexistent headers
9221		# can be detected and how.
9222	<	cat >conftest.$ac_ext <<_ACEOF
9312	<	/* confdefs.h. */
9313	<	_ACEOF
9314	<	cat confdefs.h >>conftest.$ac_ext
9315	<	cat >>conftest.$ac_ext <<_ACEOF
9222	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9223		/* end confdefs.h. */
9224		#include <ac_nonexistent.h>
9225		_ACEOF
9226	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
9320	<	case "(($ac_try" in
9321	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9322	<	*) ac_try_echo=$ac_try;;
9323	<	esac
9324	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9325	<	$as_echo "$ac_try_echo") >&5
9326	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9327	<	ac_status=$?
9328	<	grep -v '^ *+' conftest.er1 >conftest.err
9329	<	rm -f conftest.er1
9330	<	cat conftest.err >&5
9331	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9332	<	(exit $ac_status); } >/dev/null && {
9333	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" \|\|
9334	<	test ! -s conftest.err
9335	<	}; then
9226	>	if ac_fn_cxx_try_cpp "$LINENO"; then :
9227		# Broken: success on invalid input.
9228		continue
9229		else
9339	–	$as_echo "$as_me: failed program was:" >&5
9340	–	sed 's/^/\| /' conftest.$ac_ext >&5
9341	–
9230		# Passes both tests.
9231		ac_preproc_ok=:
9232		break
9233		fi
9346	–
9234		rm -f conftest.err conftest.$ac_ext
9235
9236		done
9237		# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9238		rm -f conftest.err conftest.$ac_ext
9239	<	if $ac_preproc_ok; then
9239	>	if $ac_preproc_ok; then :
9240		break
9241		fi
9242
#	Line 9361 \| Line 9248 \| fi
9248		else
9249		ac_cv_prog_CXXCPP=$CXXCPP
9250		fi
9251	<	{ $as_echo "$as_me:$LINENO: result: $CXXCPP" >&5
9251	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
9252		$as_echo "$CXXCPP" >&6; }
9253		ac_preproc_ok=false
9254		for ac_cxx_preproc_warn_flag in '' yes
#	Line 9372 \| Line 9259 \| do
9259		# <limits.h> exists even on freestanding compilers.
9260		# On the NeXT, cc -E runs the code through the compiler's parser,
9261		# not just through cpp. "Syntax error" is here to catch this case.
9262	<	cat >conftest.$ac_ext <<_ACEOF
9376	<	/* confdefs.h. */
9377	<	_ACEOF
9378	<	cat confdefs.h >>conftest.$ac_ext
9379	<	cat >>conftest.$ac_ext <<_ACEOF
9262	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9263		/* end confdefs.h. */
9264		#ifdef __STDC__
9265		# include <limits.h>
#	Line 9385 \| Line 9268 \| _ACEOF
9268		#endif
9269		Syntax error
9270		_ACEOF
9271	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
9389	<	case "(($ac_try" in
9390	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9391	<	*) ac_try_echo=$ac_try;;
9392	<	esac
9393	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9394	<	$as_echo "$ac_try_echo") >&5
9395	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9396	<	ac_status=$?
9397	<	grep -v '^ *+' conftest.er1 >conftest.err
9398	<	rm -f conftest.er1
9399	<	cat conftest.err >&5
9400	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9401	<	(exit $ac_status); } >/dev/null && {
9402	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" \|\|
9403	<	test ! -s conftest.err
9404	<	}; then
9405	<	:
9406	<	else
9407	<	$as_echo "$as_me: failed program was:" >&5
9408	<	sed 's/^/\| /' conftest.$ac_ext >&5
9271	>	if ac_fn_cxx_try_cpp "$LINENO"; then :
9272
9273	+	else
9274		# Broken: fails on valid input.
9275		continue
9276		fi
9413	–
9277		rm -f conftest.err conftest.$ac_ext
9278
9279		# OK, works on sane cases. Now check whether nonexistent headers
9280		# can be detected and how.
9281	<	cat >conftest.$ac_ext <<_ACEOF
9419	<	/* confdefs.h. */
9420	<	_ACEOF
9421	<	cat confdefs.h >>conftest.$ac_ext
9422	<	cat >>conftest.$ac_ext <<_ACEOF
9281	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9282		/* end confdefs.h. */
9283		#include <ac_nonexistent.h>
9284		_ACEOF
9285	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
9427	<	case "(($ac_try" in
9428	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9429	<	*) ac_try_echo=$ac_try;;
9430	<	esac
9431	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9432	<	$as_echo "$ac_try_echo") >&5
9433	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9434	<	ac_status=$?
9435	<	grep -v '^ *+' conftest.er1 >conftest.err
9436	<	rm -f conftest.er1
9437	<	cat conftest.err >&5
9438	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9439	<	(exit $ac_status); } >/dev/null && {
9440	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" \|\|
9441	<	test ! -s conftest.err
9442	<	}; then
9285	>	if ac_fn_cxx_try_cpp "$LINENO"; then :
9286		# Broken: success on invalid input.
9287		continue
9288		else
9446	–	$as_echo "$as_me: failed program was:" >&5
9447	–	sed 's/^/\| /' conftest.$ac_ext >&5
9448	–
9289		# Passes both tests.
9290		ac_preproc_ok=:
9291		break
9292		fi
9453	–
9293		rm -f conftest.err conftest.$ac_ext
9294
9295		done
9296		# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9297		rm -f conftest.err conftest.$ac_ext
9298	<	if $ac_preproc_ok; then
9299	<	:
9298	>	if $ac_preproc_ok; then :
9299	>
9300		else
9301	<	{ { $as_echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9302	<	See \`config.log' for more details." >&5
9303	<	$as_echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9304	<	See \`config.log' for more details." >&2;}
9466	<	{ (exit 1); exit 1; }; }
9301	>	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
9302	>	$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
9303	>	as_fn_error "C++ preprocessor \"$CXXCPP\" fails sanity check
9304	>	See \`config.log' for more details." "$LINENO" 5; }
9305		fi
9306
9307		ac_ext=cpp
#	Line 9478 \| Line 9316 \| ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9316		#
9317
9318		# Check whether --with-openbabel was given.
9319	<	if test "${with_openbabel+set}" = set; then
9319	>	if test "${with_openbabel+set}" = set; then :
9320		withval=$with_openbabel; openbabel_dir="$withval"
9321		else
9322		openbabel_dir="not_set"
#	Line 9491 \| Line 9329 \| if test "$openbabel_dir" != "not_set" ; then
9329		then
9330		OPENBABEL_HOME="$openbabel_dir"
9331		else
9332	<	{ $as_echo "$as_me:$LINENO: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
9332	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
9333		$as_echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
9334		OPENBABEL_HOME=/usr/local
9335	<	if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
9336	<	then
9337	<	OPENBABEL_HOME=/usr
9338	<	fi
9339	<	fi
9502	<	fi
9503	<	#
9504	<	# Locate openbabel, if wanted
9505	<	#
9506	<	if test -n "${OPENBABEL_HOME}"
9507	<	then
9508	<
9509	<	ac_ext=cpp
9510	<	ac_cpp='$CXXCPP $CPPFLAGS'
9511	<	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9512	<	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9513	<	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9514	<
9515	<	OPENBABEL_OLD_LDFLAGS=$LDFLAGS
9516	<	OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
9517	<	LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
9518	<	CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
9519	<	if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9520	<	{ $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9521	<	$as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9522	<	if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9523	<	$as_echo_n "(cached) " >&6
9524	<	fi
9525	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9526	<	$as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9527	<	else
9528	<	# Is the header compilable?
9529	<	{ $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h usability" >&5
9530	<	$as_echo_n "checking openbabel/babelconfig.h usability... " >&6; }
9531	<	cat >conftest.$ac_ext <<_ACEOF
9532	<	/* confdefs.h. */
9533	<	_ACEOF
9534	<	cat confdefs.h >>conftest.$ac_ext
9535	<	cat >>conftest.$ac_ext <<_ACEOF
9536	<	/* end confdefs.h. */
9537	<	$ac_includes_default
9538	<	#include <openbabel/babelconfig.h>
9539	<	_ACEOF
9540	<	rm -f conftest.$ac_objext
9541	<	if { (ac_try="$ac_compile"
9542	<	case "(($ac_try" in
9543	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9544	<	*) ac_try_echo=$ac_try;;
9545	<	esac
9546	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9547	<	$as_echo "$ac_try_echo") >&5
9548	<	(eval "$ac_compile") 2>conftest.er1
9549	<	ac_status=$?
9550	<	grep -v '^ *+' conftest.er1 >conftest.err
9551	<	rm -f conftest.er1
9552	<	cat conftest.err >&5
9553	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9554	<	(exit $ac_status); } && {
9555	<	test -z "$ac_cxx_werror_flag" \|\|
9556	<	test ! -s conftest.err
9557	<	} && test -s conftest.$ac_objext; then
9558	<	ac_header_compiler=yes
9559	<	else
9560	<	$as_echo "$as_me: failed program was:" >&5
9561	<	sed 's/^/\| /' conftest.$ac_ext >&5
9562	<
9563	<	ac_header_compiler=no
9564	<	fi
9565	<
9566	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9567	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9568	<	$as_echo "$ac_header_compiler" >&6; }
9569	<
9570	<	# Is the header present?
9571	<	{ $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h presence" >&5
9572	<	$as_echo_n "checking openbabel/babelconfig.h presence... " >&6; }
9573	<	cat >conftest.$ac_ext <<_ACEOF
9574	<	/* confdefs.h. */
9575	<	_ACEOF
9576	<	cat confdefs.h >>conftest.$ac_ext
9577	<	cat >>conftest.$ac_ext <<_ACEOF
9578	<	/* end confdefs.h. */
9579	<	#include <openbabel/babelconfig.h>
9580	<	_ACEOF
9581	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
9582	<	case "(($ac_try" in
9583	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9584	<	*) ac_try_echo=$ac_try;;
9585	<	esac
9586	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9587	<	$as_echo "$ac_try_echo") >&5
9588	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9589	<	ac_status=$?
9590	<	grep -v '^ *+' conftest.er1 >conftest.err
9591	<	rm -f conftest.er1
9592	<	cat conftest.err >&5
9593	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9594	<	(exit $ac_status); } >/dev/null && {
9595	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" \|\|
9596	<	test ! -s conftest.err
9597	<	}; then
9598	<	ac_header_preproc=yes
9599	<	else
9600	<	$as_echo "$as_me: failed program was:" >&5
9601	<	sed 's/^/\| /' conftest.$ac_ext >&5
9602	<
9603	<	ac_header_preproc=no
9604	<	fi
9605	<
9606	<	rm -f conftest.err conftest.$ac_ext
9607	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9608	<	$as_echo "$ac_header_preproc" >&6; }
9609	<
9610	<	# So? What about this header?
9611	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9612	<	yes:no: )
9613	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5
9614	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9615	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&5
9616	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&2;}
9617	<	ac_header_preproc=yes
9618	<	;;
9619	<	no:yes:* )
9620	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&5
9621	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&2;}
9622	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: check for missing prerequisite headers?" >&5
9623	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: check for missing prerequisite headers?" >&2;}
9624	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&5
9625	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&2;}
9626	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: section \"Present But Cannot Be Compiled\"" >&5
9627	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: section \"Present But Cannot Be Compiled\"" >&2;}
9628	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&5
9629	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&2;}
9630	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&5
9631	<	$as_echo "$as_me: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&2;}
9632	<	( cat <<\_ASBOX
9633	<	## ------------------------------ ##
9634	<	## Report this to gezelter@nd.edu ##
9635	<	## ------------------------------ ##
9636	<	_ASBOX
9637	<	) \| sed "s/^/$as_me: WARNING: /" >&2
9638	<	;;
9639	<	esac
9640	<	{ $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9641	<	$as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9642	<	if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9643	<	$as_echo_n "(cached) " >&6
9644	<	else
9645	<	ac_cv_header_openbabel_babelconfig_h=$ac_header_preproc
9335	>	if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
9336	>	then
9337	>	OPENBABEL_HOME=/usr
9338	>	fi
9339	>	fi
9340		fi
9341	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9342	<	$as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9341	>	#
9342	>	# Locate openbabel, if wanted
9343	>	#
9344	>	if test -n "${OPENBABEL_HOME}"
9345	>	then
9346
9347	<	fi
9348	<	if test $ac_cv_header_openbabel_babelconfig_h = yes; then
9347	>	ac_ext=cpp
9348	>	ac_cpp='$CXXCPP $CPPFLAGS'
9349	>	ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9350	>	ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9351	>	ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9352	>
9353	>	OPENBABEL_OLD_LDFLAGS=$LDFLAGS
9354	>	OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
9355	>	LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
9356	>	CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
9357	>	ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/babelconfig.h" "ac_cv_header_openbabel_babelconfig_h" "$ac_includes_default"
9358	>	if test "x$ac_cv_header_openbabel_babelconfig_h" = x""yes; then :
9359		openbabel_cv_openbabel_h=yes
9360		else
9361		openbabel_cv_openbabel_h=no
9362		fi
9363
9364
9365	<	if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9366	<	{ $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9660	<	$as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9661	<	if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9662	<	$as_echo_n "(cached) " >&6
9663	<	fi
9664	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9665	<	$as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9666	<	else
9667	<	# Is the header compilable?
9668	<	{ $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h usability" >&5
9669	<	$as_echo_n "checking openbabel/obconversion.h usability... " >&6; }
9670	<	cat >conftest.$ac_ext <<_ACEOF
9671	<	/* confdefs.h. */
9672	<	_ACEOF
9673	<	cat confdefs.h >>conftest.$ac_ext
9674	<	cat >>conftest.$ac_ext <<_ACEOF
9675	<	/* end confdefs.h. */
9676	<	$ac_includes_default
9677	<	#include <openbabel/obconversion.h>
9678	<	_ACEOF
9679	<	rm -f conftest.$ac_objext
9680	<	if { (ac_try="$ac_compile"
9681	<	case "(($ac_try" in
9682	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9683	<	*) ac_try_echo=$ac_try;;
9684	<	esac
9685	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9686	<	$as_echo "$ac_try_echo") >&5
9687	<	(eval "$ac_compile") 2>conftest.er1
9688	<	ac_status=$?
9689	<	grep -v '^ *+' conftest.er1 >conftest.err
9690	<	rm -f conftest.er1
9691	<	cat conftest.err >&5
9692	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9693	<	(exit $ac_status); } && {
9694	<	test -z "$ac_cxx_werror_flag" \|\|
9695	<	test ! -s conftest.err
9696	<	} && test -s conftest.$ac_objext; then
9697	<	ac_header_compiler=yes
9698	<	else
9699	<	$as_echo "$as_me: failed program was:" >&5
9700	<	sed 's/^/\| /' conftest.$ac_ext >&5
9701	<
9702	<	ac_header_compiler=no
9703	<	fi
9704	<
9705	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9706	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9707	<	$as_echo "$ac_header_compiler" >&6; }
9708	<
9709	<	# Is the header present?
9710	<	{ $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h presence" >&5
9711	<	$as_echo_n "checking openbabel/obconversion.h presence... " >&6; }
9712	<	cat >conftest.$ac_ext <<_ACEOF
9713	<	/* confdefs.h. */
9714	<	_ACEOF
9715	<	cat confdefs.h >>conftest.$ac_ext
9716	<	cat >>conftest.$ac_ext <<_ACEOF
9717	<	/* end confdefs.h. */
9718	<	#include <openbabel/obconversion.h>
9719	<	_ACEOF
9720	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
9721	<	case "(($ac_try" in
9722	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9723	<	*) ac_try_echo=$ac_try;;
9724	<	esac
9725	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9726	<	$as_echo "$ac_try_echo") >&5
9727	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9728	<	ac_status=$?
9729	<	grep -v '^ *+' conftest.er1 >conftest.err
9730	<	rm -f conftest.er1
9731	<	cat conftest.err >&5
9732	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9733	<	(exit $ac_status); } >/dev/null && {
9734	<	test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" \|\|
9735	<	test ! -s conftest.err
9736	<	}; then
9737	<	ac_header_preproc=yes
9738	<	else
9739	<	$as_echo "$as_me: failed program was:" >&5
9740	<	sed 's/^/\| /' conftest.$ac_ext >&5
9741	<
9742	<	ac_header_preproc=no
9743	<	fi
9744	<
9745	<	rm -f conftest.err conftest.$ac_ext
9746	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9747	<	$as_echo "$ac_header_preproc" >&6; }
9748	<
9749	<	# So? What about this header?
9750	<	case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9751	<	yes:no: )
9752	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&5
9753	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9754	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&5
9755	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&2;}
9756	<	ac_header_preproc=yes
9757	<	;;
9758	<	no:yes:* )
9759	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&5
9760	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&2;}
9761	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: check for missing prerequisite headers?" >&5
9762	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: check for missing prerequisite headers?" >&2;}
9763	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&5
9764	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&2;}
9765	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: section \"Present But Cannot Be Compiled\"" >&5
9766	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: section \"Present But Cannot Be Compiled\"" >&2;}
9767	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&5
9768	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&2;}
9769	<	{ $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&5
9770	<	$as_echo "$as_me: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&2;}
9771	<	( cat <<\_ASBOX
9772	<	## ------------------------------ ##
9773	<	## Report this to gezelter@nd.edu ##
9774	<	## ------------------------------ ##
9775	<	_ASBOX
9776	<	) \| sed "s/^/$as_me: WARNING: /" >&2
9777	<	;;
9778	<	esac
9779	<	{ $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9780	<	$as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9781	<	if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9782	<	$as_echo_n "(cached) " >&6
9783	<	else
9784	<	ac_cv_header_openbabel_obconversion_h=$ac_header_preproc
9785	<	fi
9786	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9787	<	$as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9788	<
9789	<	fi
9790	<	if test $ac_cv_header_openbabel_obconversion_h = yes; then
9365	>	ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/obconversion.h" "ac_cv_header_openbabel_obconversion_h" "$ac_includes_default"
9366	>	if test "x$ac_cv_header_openbabel_obconversion_h" = x""yes; then :
9367		openbabel_cv_obconversion_h=yes
9368		else
9369		openbabel_cv_obconversion_h=no
9370		fi
9371
9372
9373	<	cat >conftest.$ac_ext <<_ACEOF
9798	<
9799	<	/* confdefs.h. */
9800	<	_ACEOF
9801	<	cat confdefs.h >>conftest.$ac_ext
9802	<	cat >>conftest.$ac_ext <<_ACEOF
9373	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9374		/* end confdefs.h. */
9375
9376	+
9377		#include <openbabel/babelconfig.h>
9378		#include <openbabel/obconversion.h>
9379		using namespace std;
#	Line 9826 \| Line 9398 \| _ACEOF
9398		return 0;
9399		}
9400		_ACEOF
9401	<	rm -f conftest.$ac_objext conftest$ac_exeext
9830	<	if { (ac_try="$ac_link"
9831	<	case "(($ac_try" in
9832	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9833	<	*) ac_try_echo=$ac_try;;
9834	<	esac
9835	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9836	<	$as_echo "$ac_try_echo") >&5
9837	<	(eval "$ac_link") 2>conftest.er1
9838	<	ac_status=$?
9839	<	grep -v '^ *+' conftest.er1 >conftest.err
9840	<	rm -f conftest.er1
9841	<	cat conftest.err >&5
9842	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9843	<	(exit $ac_status); } && {
9844	<	test -z "$ac_cxx_werror_flag" \|\|
9845	<	test ! -s conftest.err
9846	<	} && test -s conftest$ac_exeext && {
9847	<	test "$cross_compiling" = yes \|\|
9848	<	$as_test_x conftest$ac_exeext
9849	<	}; then
9401	>	if ac_fn_cxx_try_link "$LINENO"; then :
9402
9403		openbabel_lib_found="yes"
9404	<	{ $as_echo "$as_me:$LINENO: result: found" >&5
9404	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
9405		$as_echo "found" >&6; }
9406
9407		else
9856	–	$as_echo "$as_me: failed program was:" >&5
9857	–	sed 's/^/\| /' conftest.$ac_ext >&5
9408
9859	–
9409		openbabel_lib_found="no"
9410	<	{ $as_echo "$as_me:$LINENO: result: not found" >&5
9410	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9411		$as_echo "not found" >&6; }
9412
9413
9414		fi
9415	<
9416	<	rm -rf conftest.dSYM
9868	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9869	<	conftest$ac_exeext conftest.$ac_ext
9415	>	rm -f core conftest.err conftest.$ac_objext \
9416	>	conftest$ac_exeext conftest.$ac_ext
9417		ac_ext=c
9418		ac_cpp='$CPP $CPPFLAGS'
9419		ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
#	Line 9882 \| Line 9429 \| ac_compiler_gnu=$ac_cv_c_compiler_gnu
9429		OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
9430		OPENBABEL_LIB="-lopenbabel"
9431		else
9432	<	{ $as_echo "$as_me:$LINENO: checking openbabel in ${OPENBABEL_HOME}" >&5
9432	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking openbabel in ${OPENBABEL_HOME}" >&5
9433		$as_echo_n "checking openbabel in ${OPENBABEL_HOME}... " >&6; }
9434		OPENBABEL_INC_DIR=
9435		OPENBABEL_LIB_DIR=
9436		OPENBABEL_LIB=
9437		USE_OPENBABEL=no
9438	<	{ $as_echo "$as_me:$LINENO: result: failed" >&5
9438	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
9439		$as_echo "failed" >&6; }
9440		echo ""
9441		echo "*********************************************************"
#	Line 9910 \| Line 9457 \| fi
9457
9458
9459		# Checks for header files.
9460	<	{ $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
9460	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
9461		$as_echo_n "checking for ANSI C header files... " >&6; }
9462	<	if test "${ac_cv_header_stdc+set}" = set; then
9462	>	if test "${ac_cv_header_stdc+set}" = set; then :
9463		$as_echo_n "(cached) " >&6
9464		else
9465	<	cat >conftest.$ac_ext <<_ACEOF
9919	<	/* confdefs.h. */
9920	<	_ACEOF
9921	<	cat confdefs.h >>conftest.$ac_ext
9922	<	cat >>conftest.$ac_ext <<_ACEOF
9465	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9466		/* end confdefs.h. */
9467		#include <stdlib.h>
9468		#include <stdarg.h>
#	Line 9942 \| Line 9485 \| _ACEOF
9485		return 0;
9486		}
9487		_ACEOF
9488	<	rm -f conftest.$ac_objext
9946	<	if { (ac_try="$ac_compile"
9947	<	case "(($ac_try" in
9948	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
9949	<	*) ac_try_echo=$ac_try;;
9950	<	esac
9951	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9952	<	$as_echo "$ac_try_echo") >&5
9953	<	(eval "$ac_compile") 2>conftest.er1
9954	<	ac_status=$?
9955	<	grep -v '^ *+' conftest.er1 >conftest.err
9956	<	rm -f conftest.er1
9957	<	cat conftest.err >&5
9958	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9959	<	(exit $ac_status); } && {
9960	<	test -z "$ac_c_werror_flag" \|\|
9961	<	test ! -s conftest.err
9962	<	} && test -s conftest.$ac_objext; then
9488	>	if ac_fn_c_try_compile "$LINENO"; then :
9489		ac_cv_header_stdc=yes
9490		else
9491	<	$as_echo "$as_me: failed program was:" >&5
9966	<	sed 's/^/\| /' conftest.$ac_ext >&5
9967	<
9968	<	ac_cv_header_stdc=no
9491	>	ac_cv_header_stdc=no
9492		fi
9970	–
9493		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9494
9495		if test $ac_cv_header_stdc = yes; then
9496		# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
9497	<	cat >conftest.$ac_ext <<_ACEOF
9976	<	/* confdefs.h. */
9977	<	_ACEOF
9978	<	cat confdefs.h >>conftest.$ac_ext
9979	<	cat >>conftest.$ac_ext <<_ACEOF
9497	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9498		/* end confdefs.h. */
9499		#include <string.h>
9500
9501		_ACEOF
9502		if (eval "$ac_cpp conftest.$ac_ext") 2>&5 \|
9503	<	$EGREP "memchr" >/dev/null 2>&1; then
9504	<	:
9503	>	$EGREP "memchr" >/dev/null 2>&1; then :
9504	>
9505		else
9506		ac_cv_header_stdc=no
9507		fi
#	Line 9993 \| Line 9511 \| if test $ac_cv_header_stdc = yes; then
9511
9512		if test $ac_cv_header_stdc = yes; then
9513		# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
9514	<	cat >conftest.$ac_ext <<_ACEOF
9997	<	/* confdefs.h. */
9998	<	_ACEOF
9999	<	cat confdefs.h >>conftest.$ac_ext
10000	<	cat >>conftest.$ac_ext <<_ACEOF
9514	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9515		/* end confdefs.h. */
9516		#include <stdlib.h>
9517
9518		_ACEOF
9519		if (eval "$ac_cpp conftest.$ac_ext") 2>&5 \|
9520	<	$EGREP "free" >/dev/null 2>&1; then
9521	<	:
9520	>	$EGREP "free" >/dev/null 2>&1; then :
9521	>
9522		else
9523		ac_cv_header_stdc=no
9524		fi
#	Line 10014 \| Line 9528 \| if test $ac_cv_header_stdc = yes; then
9528
9529		if test $ac_cv_header_stdc = yes; then
9530		# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
9531	<	if test "$cross_compiling" = yes; then
9531	>	if test "$cross_compiling" = yes; then :
9532		:
9533		else
9534	<	cat >conftest.$ac_ext <<_ACEOF
10021	<	/* confdefs.h. */
10022	<	_ACEOF
10023	<	cat confdefs.h >>conftest.$ac_ext
10024	<	cat >>conftest.$ac_ext <<_ACEOF
9534	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9535		/* end confdefs.h. */
9536		#include <ctype.h>
9537		#include <stdlib.h>
#	Line 10048 \| Line 9558 \| _ACEOF
9558		return 0;
9559		}
9560		_ACEOF
9561	<	rm -f conftest$ac_exeext
10052	<	if { (ac_try="$ac_link"
10053	<	case "(($ac_try" in
10054	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10055	<	*) ac_try_echo=$ac_try;;
10056	<	esac
10057	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10058	<	$as_echo "$ac_try_echo") >&5
10059	<	(eval "$ac_link") 2>&5
10060	<	ac_status=$?
10061	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10062	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10063	<	{ (case "(($ac_try" in
10064	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10065	<	*) ac_try_echo=$ac_try;;
10066	<	esac
10067	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10068	<	$as_echo "$ac_try_echo") >&5
10069	<	(eval "$ac_try") 2>&5
10070	<	ac_status=$?
10071	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10072	<	(exit $ac_status); }; }; then
10073	<	:
10074	<	else
10075	<	$as_echo "$as_me: program exited with status $ac_status" >&5
10076	<	$as_echo "$as_me: failed program was:" >&5
10077	<	sed 's/^/\| /' conftest.$ac_ext >&5
9561	>	if ac_fn_c_try_run "$LINENO"; then :
9562
9563	<	( exit $ac_status )
9564	<	ac_cv_header_stdc=no
9563	>	else
9564	>	ac_cv_header_stdc=no
9565		fi
9566	<	rm -rf conftest.dSYM
9567	<	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9566	>	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \
9567	>	conftest.$ac_objext conftest.beam conftest.$ac_ext
9568		fi
9569
10086	–
9570		fi
9571		fi
9572	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
9572	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
9573		$as_echo "$ac_cv_header_stdc" >&6; }
9574		if test $ac_cv_header_stdc = yes; then
9575
9576	<	cat >>confdefs.h <<\_ACEOF
10094	<	#define STDC_HEADERS 1
10095	<	_ACEOF
9576	>	$as_echo "#define STDC_HEADERS 1" >>confdefs.h
9577
9578		fi
9579
10099	–
10100	–
10101	–
10102	–
10103	–
10104	–
10105	–
10106	–
10107	–
10108	–
10109	–
10110	–
10111	–
10112	–
10113	–
9580		for ac_header in libintl.h limits.h machine/hal_sysinfo.h stdlib.h string.h strings.h sys/param.h sys/pstat.h sys/sysctl.h sys/sysinfo.h sys/sysmp.h sys/systemcfg.h sys/table.h sys/time.h unistd.h
9581	<	do
9582	<	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
9583	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9584	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
9585	<	$as_echo_n "checking for $ac_header... " >&6; }
10120	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10121	<	$as_echo_n "(cached) " >&6
10122	<	fi
10123	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
10124	<	$as_echo "$as_val"'`
10125	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10126	<	$as_echo "$ac_res" >&6; }
10127	<	else
10128	<	# Is the header compilable?
10129	<	{ $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
10130	<	$as_echo_n "checking $ac_header usability... " >&6; }
10131	<	cat >conftest.$ac_ext <<_ACEOF
10132	<	/* confdefs.h. */
10133	<	_ACEOF
10134	<	cat confdefs.h >>conftest.$ac_ext
10135	<	cat >>conftest.$ac_ext <<_ACEOF
10136	<	/* end confdefs.h. */
10137	<	$ac_includes_default
10138	<	#include <$ac_header>
10139	<	_ACEOF
10140	<	rm -f conftest.$ac_objext
10141	<	if { (ac_try="$ac_compile"
10142	<	case "(($ac_try" in
10143	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10144	<	*) ac_try_echo=$ac_try;;
10145	<	esac
10146	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10147	<	$as_echo "$ac_try_echo") >&5
10148	<	(eval "$ac_compile") 2>conftest.er1
10149	<	ac_status=$?
10150	<	grep -v '^ *+' conftest.er1 >conftest.err
10151	<	rm -f conftest.er1
10152	<	cat conftest.err >&5
10153	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10154	<	(exit $ac_status); } && {
10155	<	test -z "$ac_c_werror_flag" \|\|
10156	<	test ! -s conftest.err
10157	<	} && test -s conftest.$ac_objext; then
10158	<	ac_header_compiler=yes
10159	<	else
10160	<	$as_echo "$as_me: failed program was:" >&5
10161	<	sed 's/^/\| /' conftest.$ac_ext >&5
10162	<
10163	<	ac_header_compiler=no
10164	<	fi
10165	<
10166	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10167	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10168	<	$as_echo "$ac_header_compiler" >&6; }
10169	<
10170	<	# Is the header present?
10171	<	{ $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
10172	<	$as_echo_n "checking $ac_header presence... " >&6; }
10173	<	cat >conftest.$ac_ext <<_ACEOF
10174	<	/* confdefs.h. */
10175	<	_ACEOF
10176	<	cat confdefs.h >>conftest.$ac_ext
10177	<	cat >>conftest.$ac_ext <<_ACEOF
10178	<	/* end confdefs.h. */
10179	<	#include <$ac_header>
10180	<	_ACEOF
10181	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
10182	<	case "(($ac_try" in
10183	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10184	<	*) ac_try_echo=$ac_try;;
10185	<	esac
10186	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10187	<	$as_echo "$ac_try_echo") >&5
10188	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10189	<	ac_status=$?
10190	<	grep -v '^ *+' conftest.er1 >conftest.err
10191	<	rm -f conftest.er1
10192	<	cat conftest.err >&5
10193	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10194	<	(exit $ac_status); } >/dev/null && {
10195	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
10196	<	test ! -s conftest.err
10197	<	}; then
10198	<	ac_header_preproc=yes
10199	<	else
10200	<	$as_echo "$as_me: failed program was:" >&5
10201	<	sed 's/^/\| /' conftest.$ac_ext >&5
10202	<
10203	<	ac_header_preproc=no
10204	<	fi
10205	<
10206	<	rm -f conftest.err conftest.$ac_ext
10207	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10208	<	$as_echo "$ac_header_preproc" >&6; }
10209	<
10210	<	# So? What about this header?
10211	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10212	<	yes:no: )
10213	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10214	<	$as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10215	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10216	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10217	<	ac_header_preproc=yes
10218	<	;;
10219	<	no:yes:* )
10220	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10221	<	$as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10222	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
10223	<	$as_echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
10224	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10225	<	$as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10226	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5
10227	<	$as_echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}
10228	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10229	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10230	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10231	<	$as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10232	<	( cat <<\_ASBOX
10233	<	## ------------------------------ ##
10234	<	## Report this to gezelter@nd.edu ##
10235	<	## ------------------------------ ##
10236	<	_ASBOX
10237	<	) \| sed "s/^/$as_me: WARNING: /" >&2
10238	<	;;
10239	<	esac
10240	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10241	<	$as_echo_n "checking for $ac_header... " >&6; }
10242	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10243	<	$as_echo_n "(cached) " >&6
10244	<	else
10245	<	eval "$as_ac_Header=\$ac_header_preproc"
10246	<	fi
10247	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
10248	<	$as_echo "$as_val"'`
10249	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10250	<	$as_echo "$ac_res" >&6; }
10251	<
10252	<	fi
10253	<	if test `eval 'as_val=${'$as_ac_Header'}
10254	<	$as_echo "$as_val"'` = yes; then
9581	>	do :
9582	>	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
9583	>	ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
9584	>	eval as_val=\$$as_ac_Header
9585	>	if test "x$as_val" = x""yes; then :
9586		cat >>confdefs.h <<_ACEOF
9587		#define `$as_echo "HAVE_$ac_header" \| $as_tr_cpp` 1
9588		_ACEOF
#	Line 10262 \| Line 9593 \| done
9593
9594
9595		# Checks for typedefs, structures, and compiler characteristics.
9596	<	{ $as_echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
9596	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5
9597		$as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
9598	<	if test "${ac_cv_header_stdbool_h+set}" = set; then
9598	>	if test "${ac_cv_header_stdbool_h+set}" = set; then :
9599		$as_echo_n "(cached) " >&6
9600		else
9601	<	cat >conftest.$ac_ext <<_ACEOF
10271	<	/* confdefs.h. */
10272	<	_ACEOF
10273	<	cat confdefs.h >>conftest.$ac_ext
10274	<	cat >>conftest.$ac_ext <<_ACEOF
9601	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9602		/* end confdefs.h. */
9603
9604		#include <stdbool.h>
#	Line 10359 \| Line 9686 \| _ACEOF
9686		return 0;
9687		}
9688		_ACEOF
9689	<	rm -f conftest.$ac_objext
10363	<	if { (ac_try="$ac_compile"
10364	<	case "(($ac_try" in
10365	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10366	<	*) ac_try_echo=$ac_try;;
10367	<	esac
10368	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10369	<	$as_echo "$ac_try_echo") >&5
10370	<	(eval "$ac_compile") 2>conftest.er1
10371	<	ac_status=$?
10372	<	grep -v '^ *+' conftest.er1 >conftest.err
10373	<	rm -f conftest.er1
10374	<	cat conftest.err >&5
10375	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10376	<	(exit $ac_status); } && {
10377	<	test -z "$ac_c_werror_flag" \|\|
10378	<	test ! -s conftest.err
10379	<	} && test -s conftest.$ac_objext; then
9689	>	if ac_fn_c_try_compile "$LINENO"; then :
9690		ac_cv_header_stdbool_h=yes
9691		else
9692	<	$as_echo "$as_me: failed program was:" >&5
9693	<	sed 's/^/\| /' conftest.$ac_ext >&5
10384	<
10385	<	ac_cv_header_stdbool_h=no
10386	<	fi
10387	<
9692	>	ac_cv_header_stdbool_h=no
9693	>	fi
9694		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9695		fi
9696	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
9696	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
9697		$as_echo "$ac_cv_header_stdbool_h" >&6; }
9698	<	{ $as_echo "$as_me:$LINENO: checking for _Bool" >&5
9699	<	$as_echo_n "checking for _Bool... " >&6; }
10394	<	if test "${ac_cv_type__Bool+set}" = set; then
10395	<	$as_echo_n "(cached) " >&6
10396	<	else
10397	<	ac_cv_type__Bool=no
10398	<	cat >conftest.$ac_ext <<_ACEOF
10399	<	/* confdefs.h. */
10400	<	_ACEOF
10401	<	cat confdefs.h >>conftest.$ac_ext
10402	<	cat >>conftest.$ac_ext <<_ACEOF
10403	<	/* end confdefs.h. */
10404	<	$ac_includes_default
10405	<	#ifdef FC_DUMMY_MAIN
10406	<	#ifndef FC_DUMMY_MAIN_EQ_F77
10407	<	# ifdef __cplusplus
10408	<	extern "C"
10409	<	# endif
10410	<	int FC_DUMMY_MAIN() { return 1; }
10411	<	#endif
10412	<	#endif
10413	<	int
10414	<	main ()
10415	<	{
10416	<	if (sizeof (_Bool))
10417	<	return 0;
10418	<	;
10419	<	return 0;
10420	<	}
10421	<	_ACEOF
10422	<	rm -f conftest.$ac_objext
10423	<	if { (ac_try="$ac_compile"
10424	<	case "(($ac_try" in
10425	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10426	<	*) ac_try_echo=$ac_try;;
10427	<	esac
10428	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10429	<	$as_echo "$ac_try_echo") >&5
10430	<	(eval "$ac_compile") 2>conftest.er1
10431	<	ac_status=$?
10432	<	grep -v '^ *+' conftest.er1 >conftest.err
10433	<	rm -f conftest.er1
10434	<	cat conftest.err >&5
10435	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10436	<	(exit $ac_status); } && {
10437	<	test -z "$ac_c_werror_flag" \|\|
10438	<	test ! -s conftest.err
10439	<	} && test -s conftest.$ac_objext; then
10440	<	cat >conftest.$ac_ext <<_ACEOF
10441	<	/* confdefs.h. */
10442	<	_ACEOF
10443	<	cat confdefs.h >>conftest.$ac_ext
10444	<	cat >>conftest.$ac_ext <<_ACEOF
10445	<	/* end confdefs.h. */
10446	<	$ac_includes_default
10447	<	#ifdef FC_DUMMY_MAIN
10448	<	#ifndef FC_DUMMY_MAIN_EQ_F77
10449	<	# ifdef __cplusplus
10450	<	extern "C"
10451	<	# endif
10452	<	int FC_DUMMY_MAIN() { return 1; }
10453	<	#endif
10454	<	#endif
10455	<	int
10456	<	main ()
10457	<	{
10458	<	if (sizeof ((_Bool)))
10459	<	return 0;
10460	<	;
10461	<	return 0;
10462	<	}
10463	<	_ACEOF
10464	<	rm -f conftest.$ac_objext
10465	<	if { (ac_try="$ac_compile"
10466	<	case "(($ac_try" in
10467	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10468	<	*) ac_try_echo=$ac_try;;
10469	<	esac
10470	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10471	<	$as_echo "$ac_try_echo") >&5
10472	<	(eval "$ac_compile") 2>conftest.er1
10473	<	ac_status=$?
10474	<	grep -v '^ *+' conftest.er1 >conftest.err
10475	<	rm -f conftest.er1
10476	<	cat conftest.err >&5
10477	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10478	<	(exit $ac_status); } && {
10479	<	test -z "$ac_c_werror_flag" \|\|
10480	<	test ! -s conftest.err
10481	<	} && test -s conftest.$ac_objext; then
10482	<	:
10483	<	else
10484	<	$as_echo "$as_me: failed program was:" >&5
10485	<	sed 's/^/\| /' conftest.$ac_ext >&5
9698	>	ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
9699	>	if test "x$ac_cv_type__Bool" = x""yes; then :
9700
10487	–	ac_cv_type__Bool=yes
10488	–	fi
10489	–
10490	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10491	–	else
10492	–	$as_echo "$as_me: failed program was:" >&5
10493	–	sed 's/^/\| /' conftest.$ac_ext >&5
10494	–
10495	–
10496	–	fi
10497	–
10498	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10499	–	fi
10500	–	{ $as_echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
10501	–	$as_echo "$ac_cv_type__Bool" >&6; }
10502	–	if test $ac_cv_type__Bool = yes; then
10503	–
9701		cat >>confdefs.h <<_ACEOF
9702		#define HAVE__BOOL 1
9703		_ACEOF
#	Line 10510 \| Line 9707 \| if test $ac_cv_header_stdbool_h = yes; then
9707
9708		if test $ac_cv_header_stdbool_h = yes; then
9709
9710	<	cat >>confdefs.h <<\_ACEOF
10514	<	#define HAVE_STDBOOL_H 1
10515	<	_ACEOF
9710	>	$as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h
9711
9712		fi
9713
9714	<	{ $as_echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
9714	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
9715		$as_echo_n "checking for an ANSI C-conforming const... " >&6; }
9716	<	if test "${ac_cv_c_const+set}" = set; then
9716	>	if test "${ac_cv_c_const+set}" = set; then :
9717		$as_echo_n "(cached) " >&6
9718		else
9719	<	cat >conftest.$ac_ext <<_ACEOF
10525	<	/* confdefs.h. */
10526	<	_ACEOF
10527	<	cat confdefs.h >>conftest.$ac_ext
10528	<	cat >>conftest.$ac_ext <<_ACEOF
9719	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9720		/* end confdefs.h. */
9721
9722		#ifdef FC_DUMMY_MAIN
#	Line 10593 \| Line 9784 \| _ACEOF
9784		return 0;
9785		}
9786		_ACEOF
9787	<	rm -f conftest.$ac_objext
10597	<	if { (ac_try="$ac_compile"
10598	<	case "(($ac_try" in
10599	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10600	<	*) ac_try_echo=$ac_try;;
10601	<	esac
10602	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10603	<	$as_echo "$ac_try_echo") >&5
10604	<	(eval "$ac_compile") 2>conftest.er1
10605	<	ac_status=$?
10606	<	grep -v '^ *+' conftest.er1 >conftest.err
10607	<	rm -f conftest.er1
10608	<	cat conftest.err >&5
10609	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10610	<	(exit $ac_status); } && {
10611	<	test -z "$ac_c_werror_flag" \|\|
10612	<	test ! -s conftest.err
10613	<	} && test -s conftest.$ac_objext; then
9787	>	if ac_fn_c_try_compile "$LINENO"; then :
9788		ac_cv_c_const=yes
9789		else
9790	<	$as_echo "$as_me: failed program was:" >&5
10617	<	sed 's/^/\| /' conftest.$ac_ext >&5
10618	<
10619	<	ac_cv_c_const=no
9790	>	ac_cv_c_const=no
9791		fi
10621	–
9792		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9793		fi
9794	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
9794	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
9795		$as_echo "$ac_cv_c_const" >&6; }
9796		if test $ac_cv_c_const = no; then
9797
9798	<	cat >>confdefs.h <<\_ACEOF
10629	<	#define const /**/
10630	<	_ACEOF
9798	>	$as_echo "#define const /**/" >>confdefs.h
9799
9800		fi
9801
9802	<	{ $as_echo "$as_me:$LINENO: checking for inline" >&5
9802	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
9803		$as_echo_n "checking for inline... " >&6; }
9804	<	if test "${ac_cv_c_inline+set}" = set; then
9804	>	if test "${ac_cv_c_inline+set}" = set; then :
9805		$as_echo_n "(cached) " >&6
9806		else
9807		ac_cv_c_inline=no
9808		for ac_kw in inline __inline__ __inline; do
9809	<	cat >conftest.$ac_ext <<_ACEOF
10642	<	/* confdefs.h. */
10643	<	_ACEOF
10644	<	cat confdefs.h >>conftest.$ac_ext
10645	<	cat >>conftest.$ac_ext <<_ACEOF
9809	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9810		/* end confdefs.h. */
9811		#ifndef __cplusplus
9812		typedef int foo_t;
#	Line 10651 \| Line 9815 \| _ACEOF
9815		#endif
9816
9817		_ACEOF
9818	<	rm -f conftest.$ac_objext
10655	<	if { (ac_try="$ac_compile"
10656	<	case "(($ac_try" in
10657	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10658	<	*) ac_try_echo=$ac_try;;
10659	<	esac
10660	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10661	<	$as_echo "$ac_try_echo") >&5
10662	<	(eval "$ac_compile") 2>conftest.er1
10663	<	ac_status=$?
10664	<	grep -v '^ *+' conftest.er1 >conftest.err
10665	<	rm -f conftest.er1
10666	<	cat conftest.err >&5
10667	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10668	<	(exit $ac_status); } && {
10669	<	test -z "$ac_c_werror_flag" \|\|
10670	<	test ! -s conftest.err
10671	<	} && test -s conftest.$ac_objext; then
9818	>	if ac_fn_c_try_compile "$LINENO"; then :
9819		ac_cv_c_inline=$ac_kw
10673	–	else
10674	–	$as_echo "$as_me: failed program was:" >&5
10675	–	sed 's/^/\| /' conftest.$ac_ext >&5
10676	–
10677	–
9820		fi
10679	–
9821		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9822		test "$ac_cv_c_inline" != no && break
9823		done
9824
9825		fi
9826	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
9826	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
9827		$as_echo "$ac_cv_c_inline" >&6; }
9828
10688	–
9829		case $ac_cv_c_inline in
9830		inline \| yes) ;;
9831		*)
#	Line 10701 \| Line 9841 \| esac
9841		;;
9842		esac
9843
9844	<	{ $as_echo "$as_me:$LINENO: checking for size_t" >&5
9845	<	$as_echo_n "checking for size_t... " >&6; }
10706	<	if test "${ac_cv_type_size_t+set}" = set; then
10707	<	$as_echo_n "(cached) " >&6
10708	<	else
10709	<	ac_cv_type_size_t=no
10710	<	cat >conftest.$ac_ext <<_ACEOF
10711	<	/* confdefs.h. */
10712	<	_ACEOF
10713	<	cat confdefs.h >>conftest.$ac_ext
10714	<	cat >>conftest.$ac_ext <<_ACEOF
10715	<	/* end confdefs.h. */
10716	<	$ac_includes_default
10717	<	#ifdef FC_DUMMY_MAIN
10718	<	#ifndef FC_DUMMY_MAIN_EQ_F77
10719	<	# ifdef __cplusplus
10720	<	extern "C"
10721	<	# endif
10722	<	int FC_DUMMY_MAIN() { return 1; }
10723	<	#endif
10724	<	#endif
10725	<	int
10726	<	main ()
10727	<	{
10728	<	if (sizeof (size_t))
10729	<	return 0;
10730	<	;
10731	<	return 0;
10732	<	}
10733	<	_ACEOF
10734	<	rm -f conftest.$ac_objext
10735	<	if { (ac_try="$ac_compile"
10736	<	case "(($ac_try" in
10737	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10738	<	*) ac_try_echo=$ac_try;;
10739	<	esac
10740	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10741	<	$as_echo "$ac_try_echo") >&5
10742	<	(eval "$ac_compile") 2>conftest.er1
10743	<	ac_status=$?
10744	<	grep -v '^ *+' conftest.er1 >conftest.err
10745	<	rm -f conftest.er1
10746	<	cat conftest.err >&5
10747	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10748	<	(exit $ac_status); } && {
10749	<	test -z "$ac_c_werror_flag" \|\|
10750	<	test ! -s conftest.err
10751	<	} && test -s conftest.$ac_objext; then
10752	<	cat >conftest.$ac_ext <<_ACEOF
10753	<	/* confdefs.h. */
10754	<	_ACEOF
10755	<	cat confdefs.h >>conftest.$ac_ext
10756	<	cat >>conftest.$ac_ext <<_ACEOF
10757	<	/* end confdefs.h. */
10758	<	$ac_includes_default
10759	<	#ifdef FC_DUMMY_MAIN
10760	<	#ifndef FC_DUMMY_MAIN_EQ_F77
10761	<	# ifdef __cplusplus
10762	<	extern "C"
10763	<	# endif
10764	<	int FC_DUMMY_MAIN() { return 1; }
10765	<	#endif
10766	<	#endif
10767	<	int
10768	<	main ()
10769	<	{
10770	<	if (sizeof ((size_t)))
10771	<	return 0;
10772	<	;
10773	<	return 0;
10774	<	}
10775	<	_ACEOF
10776	<	rm -f conftest.$ac_objext
10777	<	if { (ac_try="$ac_compile"
10778	<	case "(($ac_try" in
10779	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10780	<	*) ac_try_echo=$ac_try;;
10781	<	esac
10782	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10783	<	$as_echo "$ac_try_echo") >&5
10784	<	(eval "$ac_compile") 2>conftest.er1
10785	<	ac_status=$?
10786	<	grep -v '^ *+' conftest.er1 >conftest.err
10787	<	rm -f conftest.er1
10788	<	cat conftest.err >&5
10789	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10790	<	(exit $ac_status); } && {
10791	<	test -z "$ac_c_werror_flag" \|\|
10792	<	test ! -s conftest.err
10793	<	} && test -s conftest.$ac_objext; then
10794	<	:
10795	<	else
10796	<	$as_echo "$as_me: failed program was:" >&5
10797	<	sed 's/^/\| /' conftest.$ac_ext >&5
9844	>	ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
9845	>	if test "x$ac_cv_type_size_t" = x""yes; then :
9846
10799	–	ac_cv_type_size_t=yes
10800	–	fi
10801	–
10802	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9847		else
10804	–	$as_echo "$as_me: failed program was:" >&5
10805	–	sed 's/^/\| /' conftest.$ac_ext >&5
9848
10807	–
10808	–	fi
10809	–
10810	–	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10811	–	fi
10812	–	{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
10813	–	$as_echo "$ac_cv_type_size_t" >&6; }
10814	–	if test $ac_cv_type_size_t = yes; then
10815	–	:
10816	–	else
10817	–
9849		cat >>confdefs.h <<_ACEOF
9850		#define size_t unsigned int
9851		_ACEOF
9852
9853		fi
9854
9855	<	{ $as_echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
9855	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
9856		$as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
9857	<	if test "${ac_cv_header_time+set}" = set; then
9857	>	if test "${ac_cv_header_time+set}" = set; then :
9858		$as_echo_n "(cached) " >&6
9859		else
9860	<	cat >conftest.$ac_ext <<_ACEOF
10830	<	/* confdefs.h. */
10831	<	_ACEOF
10832	<	cat confdefs.h >>conftest.$ac_ext
10833	<	cat >>conftest.$ac_ext <<_ACEOF
9860	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9861		/* end confdefs.h. */
9862		#include <sys/types.h>
9863		#include <sys/time.h>
#	Line 10853 \| Line 9880 \| _ACEOF
9880		return 0;
9881		}
9882		_ACEOF
9883	<	rm -f conftest.$ac_objext
10857	<	if { (ac_try="$ac_compile"
10858	<	case "(($ac_try" in
10859	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10860	<	*) ac_try_echo=$ac_try;;
10861	<	esac
10862	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10863	<	$as_echo "$ac_try_echo") >&5
10864	<	(eval "$ac_compile") 2>conftest.er1
10865	<	ac_status=$?
10866	<	grep -v '^ *+' conftest.er1 >conftest.err
10867	<	rm -f conftest.er1
10868	<	cat conftest.err >&5
10869	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10870	<	(exit $ac_status); } && {
10871	<	test -z "$ac_c_werror_flag" \|\|
10872	<	test ! -s conftest.err
10873	<	} && test -s conftest.$ac_objext; then
9883	>	if ac_fn_c_try_compile "$LINENO"; then :
9884		ac_cv_header_time=yes
9885		else
9886	<	$as_echo "$as_me: failed program was:" >&5
10877	<	sed 's/^/\| /' conftest.$ac_ext >&5
10878	<
10879	<	ac_cv_header_time=no
9886	>	ac_cv_header_time=no
9887		fi
10881	–
9888		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9889		fi
9890	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
9890	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
9891		$as_echo "$ac_cv_header_time" >&6; }
9892		if test $ac_cv_header_time = yes; then
9893
9894	<	cat >>confdefs.h <<\_ACEOF
10889	<	#define TIME_WITH_SYS_TIME 1
10890	<	_ACEOF
9894	>	$as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
9895
9896		fi
9897
9898
9899		# Checks for library functions.
10896	–
9900		for ac_header in stdlib.h
9901	<	do
9902	<	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
9903	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10901	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10902	<	$as_echo_n "checking for $ac_header... " >&6; }
10903	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10904	<	$as_echo_n "(cached) " >&6
10905	<	fi
10906	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
10907	<	$as_echo "$as_val"'`
10908	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10909	<	$as_echo "$ac_res" >&6; }
10910	<	else
10911	<	# Is the header compilable?
10912	<	{ $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
10913	<	$as_echo_n "checking $ac_header usability... " >&6; }
10914	<	cat >conftest.$ac_ext <<_ACEOF
10915	<	/* confdefs.h. */
10916	<	_ACEOF
10917	<	cat confdefs.h >>conftest.$ac_ext
10918	<	cat >>conftest.$ac_ext <<_ACEOF
10919	<	/* end confdefs.h. */
10920	<	$ac_includes_default
10921	<	#include <$ac_header>
10922	<	_ACEOF
10923	<	rm -f conftest.$ac_objext
10924	<	if { (ac_try="$ac_compile"
10925	<	case "(($ac_try" in
10926	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10927	<	*) ac_try_echo=$ac_try;;
10928	<	esac
10929	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10930	<	$as_echo "$ac_try_echo") >&5
10931	<	(eval "$ac_compile") 2>conftest.er1
10932	<	ac_status=$?
10933	<	grep -v '^ *+' conftest.er1 >conftest.err
10934	<	rm -f conftest.er1
10935	<	cat conftest.err >&5
10936	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10937	<	(exit $ac_status); } && {
10938	<	test -z "$ac_c_werror_flag" \|\|
10939	<	test ! -s conftest.err
10940	<	} && test -s conftest.$ac_objext; then
10941	<	ac_header_compiler=yes
10942	<	else
10943	<	$as_echo "$as_me: failed program was:" >&5
10944	<	sed 's/^/\| /' conftest.$ac_ext >&5
10945	<
10946	<	ac_header_compiler=no
10947	<	fi
10948	<
10949	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10950	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10951	<	$as_echo "$ac_header_compiler" >&6; }
10952	<
10953	<	# Is the header present?
10954	<	{ $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
10955	<	$as_echo_n "checking $ac_header presence... " >&6; }
10956	<	cat >conftest.$ac_ext <<_ACEOF
10957	<	/* confdefs.h. */
10958	<	_ACEOF
10959	<	cat confdefs.h >>conftest.$ac_ext
10960	<	cat >>conftest.$ac_ext <<_ACEOF
10961	<	/* end confdefs.h. */
10962	<	#include <$ac_header>
10963	<	_ACEOF
10964	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
10965	<	case "(($ac_try" in
10966	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10967	<	*) ac_try_echo=$ac_try;;
10968	<	esac
10969	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10970	<	$as_echo "$ac_try_echo") >&5
10971	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10972	<	ac_status=$?
10973	<	grep -v '^ *+' conftest.er1 >conftest.err
10974	<	rm -f conftest.er1
10975	<	cat conftest.err >&5
10976	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10977	<	(exit $ac_status); } >/dev/null && {
10978	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
10979	<	test ! -s conftest.err
10980	<	}; then
10981	<	ac_header_preproc=yes
10982	<	else
10983	<	$as_echo "$as_me: failed program was:" >&5
10984	<	sed 's/^/\| /' conftest.$ac_ext >&5
10985	<
10986	<	ac_header_preproc=no
10987	<	fi
10988	<
10989	<	rm -f conftest.err conftest.$ac_ext
10990	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10991	<	$as_echo "$ac_header_preproc" >&6; }
10992	<
10993	<	# So? What about this header?
10994	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10995	<	yes:no: )
10996	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10997	<	$as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10998	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10999	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11000	<	ac_header_preproc=yes
11001	<	;;
11002	<	no:yes:* )
11003	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11004	<	$as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11005	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
11006	<	$as_echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
11007	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11008	<	$as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11009	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5
11010	<	$as_echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}
11011	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11012	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11013	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11014	<	$as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11015	<	( cat <<\_ASBOX
11016	<	## ------------------------------ ##
11017	<	## Report this to gezelter@nd.edu ##
11018	<	## ------------------------------ ##
11019	<	_ASBOX
11020	<	) \| sed "s/^/$as_me: WARNING: /" >&2
11021	<	;;
11022	<	esac
11023	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11024	<	$as_echo_n "checking for $ac_header... " >&6; }
11025	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11026	<	$as_echo_n "(cached) " >&6
11027	<	else
11028	<	eval "$as_ac_Header=\$ac_header_preproc"
11029	<	fi
11030	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
11031	<	$as_echo "$as_val"'`
11032	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11033	<	$as_echo "$ac_res" >&6; }
11034	<
11035	<	fi
11036	<	if test `eval 'as_val=${'$as_ac_Header'}
11037	<	$as_echo "$as_val"'` = yes; then
9901	>	do :
9902	>	ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
9903	>	if test "x$ac_cv_header_stdlib_h" = x""yes; then :
9904		cat >>confdefs.h <<_ACEOF
9905	<	#define `$as_echo "HAVE_$ac_header" \| $as_tr_cpp` 1
9905	>	#define HAVE_STDLIB_H 1
9906		_ACEOF
9907
9908		fi
9909
9910		done
9911
9912	<	{ $as_echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
9912	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
9913		$as_echo_n "checking for GNU libc compatible malloc... " >&6; }
9914	<	if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
9914	>	if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then :
9915		$as_echo_n "(cached) " >&6
9916		else
9917	<	if test "$cross_compiling" = yes; then
9917	>	if test "$cross_compiling" = yes; then :
9918		ac_cv_func_malloc_0_nonnull=no
9919		else
9920	<	cat >conftest.$ac_ext <<_ACEOF
11055	<	/* confdefs.h. */
11056	<	_ACEOF
11057	<	cat confdefs.h >>conftest.$ac_ext
11058	<	cat >>conftest.$ac_ext <<_ACEOF
9920	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9921		/* end confdefs.h. */
9922		#if defined STDC_HEADERS \|\| defined HAVE_STDLIB_H
9923		# include <stdlib.h>
#	Line 11079 \| Line 9941 \| _ACEOF
9941		return 0;
9942		}
9943		_ACEOF
9944	<	rm -f conftest$ac_exeext
11083	<	if { (ac_try="$ac_link"
11084	<	case "(($ac_try" in
11085	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11086	<	*) ac_try_echo=$ac_try;;
11087	<	esac
11088	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11089	<	$as_echo "$ac_try_echo") >&5
11090	<	(eval "$ac_link") 2>&5
11091	<	ac_status=$?
11092	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11093	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11094	<	{ (case "(($ac_try" in
11095	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11096	<	*) ac_try_echo=$ac_try;;
11097	<	esac
11098	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11099	<	$as_echo "$ac_try_echo") >&5
11100	<	(eval "$ac_try") 2>&5
11101	<	ac_status=$?
11102	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11103	<	(exit $ac_status); }; }; then
9944	>	if ac_fn_c_try_run "$LINENO"; then :
9945		ac_cv_func_malloc_0_nonnull=yes
9946		else
9947	<	$as_echo "$as_me: program exited with status $ac_status" >&5
11107	<	$as_echo "$as_me: failed program was:" >&5
11108	<	sed 's/^/\| /' conftest.$ac_ext >&5
11109	<
11110	<	( exit $ac_status )
11111	<	ac_cv_func_malloc_0_nonnull=no
9947	>	ac_cv_func_malloc_0_nonnull=no
9948		fi
9949	<	rm -rf conftest.dSYM
9950	<	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9949	>	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \
9950	>	conftest.$ac_objext conftest.beam conftest.$ac_ext
9951		fi
9952
11117	–
9953		fi
9954	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
9954	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
9955		$as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
9956	<	if test $ac_cv_func_malloc_0_nonnull = yes; then
9956	>	if test $ac_cv_func_malloc_0_nonnull = yes; then :
9957
9958	<	cat >>confdefs.h <<\_ACEOF
11124	<	#define HAVE_MALLOC 1
11125	<	_ACEOF
9958	>	$as_echo "#define HAVE_MALLOC 1" >>confdefs.h
9959
9960		else
9961	<	cat >>confdefs.h <<\_ACEOF
11129	<	#define HAVE_MALLOC 0
11130	<	_ACEOF
9961	>	$as_echo "#define HAVE_MALLOC 0" >>confdefs.h
9962
9963		case " $LIBOBJS " in
9964		" malloc.$ac_objext " ) ;;
#	Line 11136 \| Line 9967 \| esac
9967		esac
9968
9969
9970	<	cat >>confdefs.h <<\_ACEOF
11140	<	#define malloc rpl_malloc
11141	<	_ACEOF
9970	>	$as_echo "#define malloc rpl_malloc" >>confdefs.h
9971
9972		fi
9973
9974
11146	–
11147	–
9975		for ac_header in stdlib.h
9976	<	do
9977	<	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
9978	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11152	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11153	<	$as_echo_n "checking for $ac_header... " >&6; }
11154	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11155	<	$as_echo_n "(cached) " >&6
11156	<	fi
11157	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
11158	<	$as_echo "$as_val"'`
11159	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11160	<	$as_echo "$ac_res" >&6; }
11161	<	else
11162	<	# Is the header compilable?
11163	<	{ $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11164	<	$as_echo_n "checking $ac_header usability... " >&6; }
11165	<	cat >conftest.$ac_ext <<_ACEOF
11166	<	/* confdefs.h. */
11167	<	_ACEOF
11168	<	cat confdefs.h >>conftest.$ac_ext
11169	<	cat >>conftest.$ac_ext <<_ACEOF
11170	<	/* end confdefs.h. */
11171	<	$ac_includes_default
11172	<	#include <$ac_header>
11173	<	_ACEOF
11174	<	rm -f conftest.$ac_objext
11175	<	if { (ac_try="$ac_compile"
11176	<	case "(($ac_try" in
11177	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11178	<	*) ac_try_echo=$ac_try;;
11179	<	esac
11180	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11181	<	$as_echo "$ac_try_echo") >&5
11182	<	(eval "$ac_compile") 2>conftest.er1
11183	<	ac_status=$?
11184	<	grep -v '^ *+' conftest.er1 >conftest.err
11185	<	rm -f conftest.er1
11186	<	cat conftest.err >&5
11187	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11188	<	(exit $ac_status); } && {
11189	<	test -z "$ac_c_werror_flag" \|\|
11190	<	test ! -s conftest.err
11191	<	} && test -s conftest.$ac_objext; then
11192	<	ac_header_compiler=yes
11193	<	else
11194	<	$as_echo "$as_me: failed program was:" >&5
11195	<	sed 's/^/\| /' conftest.$ac_ext >&5
11196	<
11197	<	ac_header_compiler=no
11198	<	fi
11199	<
11200	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11201	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11202	<	$as_echo "$ac_header_compiler" >&6; }
11203	<
11204	<	# Is the header present?
11205	<	{ $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
11206	<	$as_echo_n "checking $ac_header presence... " >&6; }
11207	<	cat >conftest.$ac_ext <<_ACEOF
11208	<	/* confdefs.h. */
11209	<	_ACEOF
11210	<	cat confdefs.h >>conftest.$ac_ext
11211	<	cat >>conftest.$ac_ext <<_ACEOF
11212	<	/* end confdefs.h. */
11213	<	#include <$ac_header>
11214	<	_ACEOF
11215	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
11216	<	case "(($ac_try" in
11217	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11218	<	*) ac_try_echo=$ac_try;;
11219	<	esac
11220	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11221	<	$as_echo "$ac_try_echo") >&5
11222	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11223	<	ac_status=$?
11224	<	grep -v '^ *+' conftest.er1 >conftest.err
11225	<	rm -f conftest.er1
11226	<	cat conftest.err >&5
11227	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11228	<	(exit $ac_status); } >/dev/null && {
11229	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
11230	<	test ! -s conftest.err
11231	<	}; then
11232	<	ac_header_preproc=yes
11233	<	else
11234	<	$as_echo "$as_me: failed program was:" >&5
11235	<	sed 's/^/\| /' conftest.$ac_ext >&5
11236	<
11237	<	ac_header_preproc=no
11238	<	fi
11239	<
11240	<	rm -f conftest.err conftest.$ac_ext
11241	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11242	<	$as_echo "$ac_header_preproc" >&6; }
11243	<
11244	<	# So? What about this header?
11245	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11246	<	yes:no: )
11247	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11248	<	$as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11249	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11250	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11251	<	ac_header_preproc=yes
11252	<	;;
11253	<	no:yes:* )
11254	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11255	<	$as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11256	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
11257	<	$as_echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
11258	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11259	<	$as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11260	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5
11261	<	$as_echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}
11262	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11263	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11264	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11265	<	$as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11266	<	( cat <<\_ASBOX
11267	<	## ------------------------------ ##
11268	<	## Report this to gezelter@nd.edu ##
11269	<	## ------------------------------ ##
11270	<	_ASBOX
11271	<	) \| sed "s/^/$as_me: WARNING: /" >&2
11272	<	;;
11273	<	esac
11274	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11275	<	$as_echo_n "checking for $ac_header... " >&6; }
11276	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11277	<	$as_echo_n "(cached) " >&6
11278	<	else
11279	<	eval "$as_ac_Header=\$ac_header_preproc"
11280	<	fi
11281	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
11282	<	$as_echo "$as_val"'`
11283	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11284	<	$as_echo "$ac_res" >&6; }
11285	<
11286	<	fi
11287	<	if test `eval 'as_val=${'$as_ac_Header'}
11288	<	$as_echo "$as_val"'` = yes; then
9976	>	do :
9977	>	ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
9978	>	if test "x$ac_cv_header_stdlib_h" = x""yes; then :
9979		cat >>confdefs.h <<_ACEOF
9980	<	#define `$as_echo "HAVE_$ac_header" \| $as_tr_cpp` 1
9980	>	#define HAVE_STDLIB_H 1
9981		_ACEOF
9982
9983		fi
9984
9985		done
9986
9987	<	{ $as_echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
9987	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
9988		$as_echo_n "checking for GNU libc compatible realloc... " >&6; }
9989	<	if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
9989	>	if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then :
9990		$as_echo_n "(cached) " >&6
9991		else
9992	<	if test "$cross_compiling" = yes; then
9992	>	if test "$cross_compiling" = yes; then :
9993		ac_cv_func_realloc_0_nonnull=no
9994		else
9995	<	cat >conftest.$ac_ext <<_ACEOF
11306	<	/* confdefs.h. */
11307	<	_ACEOF
11308	<	cat confdefs.h >>conftest.$ac_ext
11309	<	cat >>conftest.$ac_ext <<_ACEOF
9995	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9996		/* end confdefs.h. */
9997		#if defined STDC_HEADERS \|\| defined HAVE_STDLIB_H
9998		# include <stdlib.h>
#	Line 11330 \| Line 10016 \| _ACEOF
10016		return 0;
10017		}
10018		_ACEOF
10019	<	rm -f conftest$ac_exeext
11334	<	if { (ac_try="$ac_link"
11335	<	case "(($ac_try" in
11336	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11337	<	*) ac_try_echo=$ac_try;;
11338	<	esac
11339	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11340	<	$as_echo "$ac_try_echo") >&5
11341	<	(eval "$ac_link") 2>&5
11342	<	ac_status=$?
11343	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11344	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11345	<	{ (case "(($ac_try" in
11346	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11347	<	*) ac_try_echo=$ac_try;;
11348	<	esac
11349	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11350	<	$as_echo "$ac_try_echo") >&5
11351	<	(eval "$ac_try") 2>&5
11352	<	ac_status=$?
11353	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11354	<	(exit $ac_status); }; }; then
10019	>	if ac_fn_c_try_run "$LINENO"; then :
10020		ac_cv_func_realloc_0_nonnull=yes
10021		else
10022	<	$as_echo "$as_me: program exited with status $ac_status" >&5
11358	<	$as_echo "$as_me: failed program was:" >&5
11359	<	sed 's/^/\| /' conftest.$ac_ext >&5
11360	<
11361	<	( exit $ac_status )
11362	<	ac_cv_func_realloc_0_nonnull=no
10022	>	ac_cv_func_realloc_0_nonnull=no
10023		fi
10024	<	rm -rf conftest.dSYM
10025	<	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10024	>	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \
10025	>	conftest.$ac_objext conftest.beam conftest.$ac_ext
10026		fi
10027
11368	–
10028		fi
10029	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
10029	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
10030		$as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
10031	<	if test $ac_cv_func_realloc_0_nonnull = yes; then
10031	>	if test $ac_cv_func_realloc_0_nonnull = yes; then :
10032
10033	<	cat >>confdefs.h <<\_ACEOF
11375	<	#define HAVE_REALLOC 1
11376	<	_ACEOF
10033	>	$as_echo "#define HAVE_REALLOC 1" >>confdefs.h
10034
10035		else
10036	<	cat >>confdefs.h <<\_ACEOF
11380	<	#define HAVE_REALLOC 0
11381	<	_ACEOF
10036	>	$as_echo "#define HAVE_REALLOC 0" >>confdefs.h
10037
10038		case " $LIBOBJS " in
10039		" realloc.$ac_objext " ) ;;
#	Line 11387 \| Line 10042 \| esac
10042		esac
10043
10044
10045	<	cat >>confdefs.h <<\_ACEOF
11391	<	#define realloc rpl_realloc
11392	<	_ACEOF
10045	>	$as_echo "#define realloc rpl_realloc" >>confdefs.h
10046
10047		fi
10048
10049
11397	–
11398	–
11399	–
10050		for ac_header in sys/select.h sys/socket.h
10051	<	do
10052	<	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
10053	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10054	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10055	<	$as_echo_n "checking for $ac_header... " >&6; }
11406	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11407	<	$as_echo_n "(cached) " >&6
11408	<	fi
11409	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
11410	<	$as_echo "$as_val"'`
11411	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11412	<	$as_echo "$ac_res" >&6; }
11413	<	else
11414	<	# Is the header compilable?
11415	<	{ $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11416	<	$as_echo_n "checking $ac_header usability... " >&6; }
11417	<	cat >conftest.$ac_ext <<_ACEOF
11418	<	/* confdefs.h. */
11419	<	_ACEOF
11420	<	cat confdefs.h >>conftest.$ac_ext
11421	<	cat >>conftest.$ac_ext <<_ACEOF
11422	<	/* end confdefs.h. */
11423	<	$ac_includes_default
11424	<	#include <$ac_header>
11425	<	_ACEOF
11426	<	rm -f conftest.$ac_objext
11427	<	if { (ac_try="$ac_compile"
11428	<	case "(($ac_try" in
11429	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11430	<	*) ac_try_echo=$ac_try;;
11431	<	esac
11432	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11433	<	$as_echo "$ac_try_echo") >&5
11434	<	(eval "$ac_compile") 2>conftest.er1
11435	<	ac_status=$?
11436	<	grep -v '^ *+' conftest.er1 >conftest.err
11437	<	rm -f conftest.er1
11438	<	cat conftest.err >&5
11439	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11440	<	(exit $ac_status); } && {
11441	<	test -z "$ac_c_werror_flag" \|\|
11442	<	test ! -s conftest.err
11443	<	} && test -s conftest.$ac_objext; then
11444	<	ac_header_compiler=yes
11445	<	else
11446	<	$as_echo "$as_me: failed program was:" >&5
11447	<	sed 's/^/\| /' conftest.$ac_ext >&5
11448	<
11449	<	ac_header_compiler=no
11450	<	fi
11451	<
11452	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11453	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11454	<	$as_echo "$ac_header_compiler" >&6; }
11455	<
11456	<	# Is the header present?
11457	<	{ $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
11458	<	$as_echo_n "checking $ac_header presence... " >&6; }
11459	<	cat >conftest.$ac_ext <<_ACEOF
11460	<	/* confdefs.h. */
11461	<	_ACEOF
11462	<	cat confdefs.h >>conftest.$ac_ext
11463	<	cat >>conftest.$ac_ext <<_ACEOF
11464	<	/* end confdefs.h. */
11465	<	#include <$ac_header>
11466	<	_ACEOF
11467	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
11468	<	case "(($ac_try" in
11469	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11470	<	*) ac_try_echo=$ac_try;;
11471	<	esac
11472	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11473	<	$as_echo "$ac_try_echo") >&5
11474	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11475	<	ac_status=$?
11476	<	grep -v '^ *+' conftest.er1 >conftest.err
11477	<	rm -f conftest.er1
11478	<	cat conftest.err >&5
11479	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11480	<	(exit $ac_status); } >/dev/null && {
11481	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
11482	<	test ! -s conftest.err
11483	<	}; then
11484	<	ac_header_preproc=yes
11485	<	else
11486	<	$as_echo "$as_me: failed program was:" >&5
11487	<	sed 's/^/\| /' conftest.$ac_ext >&5
11488	<
11489	<	ac_header_preproc=no
11490	<	fi
11491	<
11492	<	rm -f conftest.err conftest.$ac_ext
11493	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11494	<	$as_echo "$ac_header_preproc" >&6; }
11495	<
11496	<	# So? What about this header?
11497	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11498	<	yes:no: )
11499	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11500	<	$as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11501	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11502	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11503	<	ac_header_preproc=yes
11504	<	;;
11505	<	no:yes:* )
11506	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11507	<	$as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11508	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
11509	<	$as_echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
11510	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11511	<	$as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11512	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5
11513	<	$as_echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}
11514	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11515	<	$as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11516	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11517	<	$as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11518	<	( cat <<\_ASBOX
11519	<	## ------------------------------ ##
11520	<	## Report this to gezelter@nd.edu ##
11521	<	## ------------------------------ ##
11522	<	_ASBOX
11523	<	) \| sed "s/^/$as_me: WARNING: /" >&2
11524	<	;;
11525	<	esac
11526	<	{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11527	<	$as_echo_n "checking for $ac_header... " >&6; }
11528	<	if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11529	<	$as_echo_n "(cached) " >&6
11530	<	else
11531	<	eval "$as_ac_Header=\$ac_header_preproc"
11532	<	fi
11533	<	ac_res=`eval 'as_val=${'$as_ac_Header'}
11534	<	$as_echo "$as_val"'`
11535	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11536	<	$as_echo "$ac_res" >&6; }
11537	<
11538	<	fi
11539	<	if test `eval 'as_val=${'$as_ac_Header'}
11540	<	$as_echo "$as_val"'` = yes; then
10051	>	do :
10052	>	as_ac_Header=`$as_echo "ac_cv_header_$ac_header" \| $as_tr_sh`
10053	>	ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
10054	>	eval as_val=\$$as_ac_Header
10055	>	if test "x$as_val" = x""yes; then :
10056		cat >>confdefs.h <<_ACEOF
10057		#define `$as_echo "HAVE_$ac_header" \| $as_tr_cpp` 1
10058		_ACEOF
#	Line 11546 \| Line 10061 \| done
10061
10062		done
10063
10064	<	{ $as_echo "$as_me:$LINENO: checking types of arguments for select" >&5
10064	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking types of arguments for select" >&5
10065		$as_echo_n "checking types of arguments for select... " >&6; }
10066	<	if test "${ac_cv_func_select_args+set}" = set; then
10066	>	if test "${ac_cv_func_select_args+set}" = set; then :
10067		$as_echo_n "(cached) " >&6
10068		else
10069		for ac_arg234 in 'fd_set ' 'int ' 'void *'; do
10070		for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
10071		for ac_arg5 in 'struct timeval ' 'const struct timeval '; do
10072	<	cat >conftest.$ac_ext <<_ACEOF
11558	<	/* confdefs.h. */
11559	<	_ACEOF
11560	<	cat confdefs.h >>conftest.$ac_ext
11561	<	cat >>conftest.$ac_ext <<_ACEOF
10072	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10073		/* end confdefs.h. */
10074		$ac_includes_default
10075		#ifdef HAVE_SYS_SELECT_H
#	Line 11586 \| Line 10097 \| _ACEOF
10097		return 0;
10098		}
10099		_ACEOF
10100	<	rm -f conftest.$ac_objext
11590	<	if { (ac_try="$ac_compile"
11591	<	case "(($ac_try" in
11592	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11593	<	*) ac_try_echo=$ac_try;;
11594	<	esac
11595	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11596	<	$as_echo "$ac_try_echo") >&5
11597	<	(eval "$ac_compile") 2>conftest.er1
11598	<	ac_status=$?
11599	<	grep -v '^ *+' conftest.er1 >conftest.err
11600	<	rm -f conftest.er1
11601	<	cat conftest.err >&5
11602	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11603	<	(exit $ac_status); } && {
11604	<	test -z "$ac_c_werror_flag" \|\|
11605	<	test ! -s conftest.err
11606	<	} && test -s conftest.$ac_objext; then
10100	>	if ac_fn_c_try_compile "$LINENO"; then :
10101		ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
11608	–	else
11609	–	$as_echo "$as_me: failed program was:" >&5
11610	–	sed 's/^/\| /' conftest.$ac_ext >&5
11611	–
11612	–
10102		fi
11614	–
10103		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10104		done
10105		done
#	Line 11620 \| Line 10108 \| fi
10108		: ${ac_cv_func_select_args='int,int ,struct timeval '}
10109
10110		fi
10111	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
10111	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_select_args" >&5
10112		$as_echo "$ac_cv_func_select_args" >&6; }
10113		ac_save_IFS=$IFS; IFS=','
10114		set dummy `echo "$ac_cv_func_select_args" \| sed 's/\/\/g'`
#	Line 11643 \| Line 10131 \| rm -f conftest*
10131
10132		rm -f conftest*
10133
10134	<	{ $as_echo "$as_me:$LINENO: checking for working strtod" >&5
10134	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5
10135		$as_echo_n "checking for working strtod... " >&6; }
10136	<	if test "${ac_cv_func_strtod+set}" = set; then
10136	>	if test "${ac_cv_func_strtod+set}" = set; then :
10137		$as_echo_n "(cached) " >&6
10138		else
10139	<	if test "$cross_compiling" = yes; then
10139	>	if test "$cross_compiling" = yes; then :
10140		ac_cv_func_strtod=no
10141		else
10142	<	cat >conftest.$ac_ext <<_ACEOF
11655	<	/* confdefs.h. */
11656	<	_ACEOF
11657	<	cat confdefs.h >>conftest.$ac_ext
11658	<	cat >>conftest.$ac_ext <<_ACEOF
10142	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10143		/* end confdefs.h. */
10144
10145		$ac_includes_default
#	Line 11688 \| Line 10172 \| _ACEOF
10172		}
10173
10174		_ACEOF
10175	<	rm -f conftest$ac_exeext
11692	<	if { (ac_try="$ac_link"
11693	<	case "(($ac_try" in
11694	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11695	<	*) ac_try_echo=$ac_try;;
11696	<	esac
11697	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11698	<	$as_echo "$ac_try_echo") >&5
11699	<	(eval "$ac_link") 2>&5
11700	<	ac_status=$?
11701	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11702	<	(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11703	<	{ (case "(($ac_try" in
11704	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11705	<	*) ac_try_echo=$ac_try;;
11706	<	esac
11707	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11708	<	$as_echo "$ac_try_echo") >&5
11709	<	(eval "$ac_try") 2>&5
11710	<	ac_status=$?
11711	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11712	<	(exit $ac_status); }; }; then
10175	>	if ac_fn_c_try_run "$LINENO"; then :
10176		ac_cv_func_strtod=yes
10177		else
10178	<	$as_echo "$as_me: program exited with status $ac_status" >&5
11716	<	$as_echo "$as_me: failed program was:" >&5
11717	<	sed 's/^/\| /' conftest.$ac_ext >&5
11718	<
11719	<	( exit $ac_status )
11720	<	ac_cv_func_strtod=no
10178	>	ac_cv_func_strtod=no
10179		fi
10180	<	rm -rf conftest.dSYM
10181	<	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10180	>	rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \
10181	>	conftest.$ac_objext conftest.beam conftest.$ac_ext
10182		fi
10183
11726	–
10184		fi
10185	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
10185	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5
10186		$as_echo "$ac_cv_func_strtod" >&6; }
10187		if test $ac_cv_func_strtod = no; then
10188		case " $LIBOBJS " in
#	Line 11734 \| Line 10191 \| esac
10191		;;
10192		esac
10193
10194	<	{ $as_echo "$as_me:$LINENO: checking for pow" >&5
10195	<	$as_echo_n "checking for pow... " >&6; }
11739	<	if test "${ac_cv_func_pow+set}" = set; then
11740	<	$as_echo_n "(cached) " >&6
11741	<	else
11742	<	cat >conftest.$ac_ext <<_ACEOF
11743	<	/* confdefs.h. */
11744	<	_ACEOF
11745	<	cat confdefs.h >>conftest.$ac_ext
11746	<	cat >>conftest.$ac_ext <<_ACEOF
11747	<	/* end confdefs.h. */
11748	<	/* Define pow to an innocuous variant, in case <limits.h> declares pow.
11749	<	For example, HP-UX 11i <limits.h> declares gettimeofday. */
11750	<	#define pow innocuous_pow
10194	>	ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
10195	>	if test "x$ac_cv_func_pow" = x""yes; then :
10196
11752	–	/* System header to define __stub macros and hopefully few prototypes,
11753	–	which can conflict with char pow (); below.
11754	–	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11755	–	<limits.h> exists even on freestanding compilers. */
11756	–
11757	–	#ifdef __STDC__
11758	–	# include <limits.h>
11759	–	#else
11760	–	# include <assert.h>
11761	–	#endif
11762	–
11763	–	#undef pow
11764	–
11765	–	/* Override any GCC internal prototype to avoid an error.
11766	–	Use char because int might match the return type of a GCC
11767	–	builtin and then its argument prototype would still apply. */
11768	–	#ifdef __cplusplus
11769	–	extern "C"
11770	–	#endif
11771	–	char pow ();
11772	–	/* The GNU C library defines this for functions which it implements
11773	–	to always fail with ENOSYS. Some functions are actually named
11774	–	something starting with __ and the normal name is an alias. */
11775	–	#if defined __stub_pow \|\| defined __stub___pow
11776	–	choke me
11777	–	#endif
11778	–
11779	–	#ifdef FC_DUMMY_MAIN
11780	–	#ifndef FC_DUMMY_MAIN_EQ_F77
11781	–	# ifdef __cplusplus
11782	–	extern "C"
11783	–	# endif
11784	–	int FC_DUMMY_MAIN() { return 1; }
11785	–	#endif
11786	–	#endif
11787	–	int
11788	–	main ()
11789	–	{
11790	–	return pow ();
11791	–	;
11792	–	return 0;
11793	–	}
11794	–	_ACEOF
11795	–	rm -f conftest.$ac_objext conftest$ac_exeext
11796	–	if { (ac_try="$ac_link"
11797	–	case "(($ac_try" in
11798	–	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11799	–	*) ac_try_echo=$ac_try;;
11800	–	esac
11801	–	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11802	–	$as_echo "$ac_try_echo") >&5
11803	–	(eval "$ac_link") 2>conftest.er1
11804	–	ac_status=$?
11805	–	grep -v '^ *+' conftest.er1 >conftest.err
11806	–	rm -f conftest.er1
11807	–	cat conftest.err >&5
11808	–	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11809	–	(exit $ac_status); } && {
11810	–	test -z "$ac_c_werror_flag" \|\|
11811	–	test ! -s conftest.err
11812	–	} && test -s conftest$ac_exeext && {
11813	–	test "$cross_compiling" = yes \|\|
11814	–	$as_test_x conftest$ac_exeext
11815	–	}; then
11816	–	ac_cv_func_pow=yes
11817	–	else
11818	–	$as_echo "$as_me: failed program was:" >&5
11819	–	sed 's/^/\| /' conftest.$ac_ext >&5
11820	–
11821	–	ac_cv_func_pow=no
10197		fi
10198
11824	–	rm -rf conftest.dSYM
11825	–	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11826	–	conftest$ac_exeext conftest.$ac_ext
11827	–	fi
11828	–	{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
11829	–	$as_echo "$ac_cv_func_pow" >&6; }
11830	–
10199		if test $ac_cv_func_pow = no; then
10200	<	{ $as_echo "$as_me:$LINENO: checking for pow in -lm" >&5
10200	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
10201		$as_echo_n "checking for pow in -lm... " >&6; }
10202	<	if test "${ac_cv_lib_m_pow+set}" = set; then
10202	>	if test "${ac_cv_lib_m_pow+set}" = set; then :
10203		$as_echo_n "(cached) " >&6
10204		else
10205		ac_check_lib_save_LIBS=$LIBS
10206		LIBS="-lm $LIBS"
10207	<	cat >conftest.$ac_ext <<_ACEOF
11840	<	/* confdefs.h. */
11841	<	_ACEOF
11842	<	cat confdefs.h >>conftest.$ac_ext
11843	<	cat >>conftest.$ac_ext <<_ACEOF
10207	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10208		/* end confdefs.h. */
10209
10210		/* Override any GCC internal prototype to avoid an error.
#	Line 11866 \| Line 10230 \| _ACEOF
10230		return 0;
10231		}
10232		_ACEOF
10233	<	rm -f conftest.$ac_objext conftest$ac_exeext
11870	<	if { (ac_try="$ac_link"
11871	<	case "(($ac_try" in
11872	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
11873	<	*) ac_try_echo=$ac_try;;
11874	<	esac
11875	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11876	<	$as_echo "$ac_try_echo") >&5
11877	<	(eval "$ac_link") 2>conftest.er1
11878	<	ac_status=$?
11879	<	grep -v '^ *+' conftest.er1 >conftest.err
11880	<	rm -f conftest.er1
11881	<	cat conftest.err >&5
11882	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883	<	(exit $ac_status); } && {
11884	<	test -z "$ac_c_werror_flag" \|\|
11885	<	test ! -s conftest.err
11886	<	} && test -s conftest$ac_exeext && {
11887	<	test "$cross_compiling" = yes \|\|
11888	<	$as_test_x conftest$ac_exeext
11889	<	}; then
10233	>	if ac_fn_c_try_link "$LINENO"; then :
10234		ac_cv_lib_m_pow=yes
10235		else
10236	<	$as_echo "$as_me: failed program was:" >&5
11893	<	sed 's/^/\| /' conftest.$ac_ext >&5
11894	<
11895	<	ac_cv_lib_m_pow=no
10236	>	ac_cv_lib_m_pow=no
10237		fi
10238	<
10239	<	rm -rf conftest.dSYM
11899	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11900	<	conftest$ac_exeext conftest.$ac_ext
10238	>	rm -f core conftest.err conftest.$ac_objext \
10239	>	conftest$ac_exeext conftest.$ac_ext
10240		LIBS=$ac_check_lib_save_LIBS
10241		fi
10242	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
10242	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
10243		$as_echo "$ac_cv_lib_m_pow" >&6; }
10244	<	if test $ac_cv_lib_m_pow = yes; then
10244	>	if test "x$ac_cv_lib_m_pow" = x""yes; then :
10245		POW_LIB=-lm
10246		else
10247	<	{ $as_echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
10247	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5
10248		$as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
10249		fi
10250
#	Line 11913 \| Line 10252 \| fi
10252
10253		fi
10254
11916	–
11917	–
11918	–
11919	–
11920	–
11921	–
11922	–
11923	–
11924	–
11925	–
11926	–
11927	–
11928	–
11929	–
11930	–
11931	–
11932	–
11933	–
11934	–
11935	–
11936	–
10255		for ac_func in floor getpagesize gettimeofday memset pow pstat_getdynamic pstat_getstatic select sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strstr strtol sysmp getsysinfo sysctl table
10256	<	do
10257	<	as_ac_var=`$as_echo "ac_cv_func_$ac_func" \| $as_tr_sh`
10258	<	{ $as_echo "$as_me:$LINENO: checking for $ac_func" >&5
10259	<	$as_echo_n "checking for $ac_func... " >&6; }
10260	<	if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
11943	<	$as_echo_n "(cached) " >&6
11944	<	else
11945	<	cat >conftest.$ac_ext <<_ACEOF
11946	<	/* confdefs.h. */
11947	<	_ACEOF
11948	<	cat confdefs.h >>conftest.$ac_ext
11949	<	cat >>conftest.$ac_ext <<_ACEOF
11950	<	/* end confdefs.h. */
11951	<	/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11952	<	For example, HP-UX 11i <limits.h> declares gettimeofday. */
11953	<	#define $ac_func innocuous_$ac_func
11954	<
11955	<	/* System header to define __stub macros and hopefully few prototypes,
11956	<	which can conflict with char $ac_func (); below.
11957	<	Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11958	<	<limits.h> exists even on freestanding compilers. */
11959	<
11960	<	#ifdef __STDC__
11961	<	# include <limits.h>
11962	<	#else
11963	<	# include <assert.h>
11964	<	#endif
11965	<
11966	<	#undef $ac_func
11967	<
11968	<	/* Override any GCC internal prototype to avoid an error.
11969	<	Use char because int might match the return type of a GCC
11970	<	builtin and then its argument prototype would still apply. */
11971	<	#ifdef __cplusplus
11972	<	extern "C"
11973	<	#endif
11974	<	char $ac_func ();
11975	<	/* The GNU C library defines this for functions which it implements
11976	<	to always fail with ENOSYS. Some functions are actually named
11977	<	something starting with __ and the normal name is an alias. */
11978	<	#if defined __stub_$ac_func \|\| defined __stub___$ac_func
11979	<	choke me
11980	<	#endif
11981	<
11982	<	#ifdef FC_DUMMY_MAIN
11983	<	#ifndef FC_DUMMY_MAIN_EQ_F77
11984	<	# ifdef __cplusplus
11985	<	extern "C"
11986	<	# endif
11987	<	int FC_DUMMY_MAIN() { return 1; }
11988	<	#endif
11989	<	#endif
11990	<	int
11991	<	main ()
11992	<	{
11993	<	return $ac_func ();
11994	<	;
11995	<	return 0;
11996	<	}
11997	<	_ACEOF
11998	<	rm -f conftest.$ac_objext conftest$ac_exeext
11999	<	if { (ac_try="$ac_link"
12000	<	case "(($ac_try" in
12001	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
12002	<	*) ac_try_echo=$ac_try;;
12003	<	esac
12004	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12005	<	$as_echo "$ac_try_echo") >&5
12006	<	(eval "$ac_link") 2>conftest.er1
12007	<	ac_status=$?
12008	<	grep -v '^ *+' conftest.er1 >conftest.err
12009	<	rm -f conftest.er1
12010	<	cat conftest.err >&5
12011	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12012	<	(exit $ac_status); } && {
12013	<	test -z "$ac_c_werror_flag" \|\|
12014	<	test ! -s conftest.err
12015	<	} && test -s conftest$ac_exeext && {
12016	<	test "$cross_compiling" = yes \|\|
12017	<	$as_test_x conftest$ac_exeext
12018	<	}; then
12019	<	eval "$as_ac_var=yes"
12020	<	else
12021	<	$as_echo "$as_me: failed program was:" >&5
12022	<	sed 's/^/\| /' conftest.$ac_ext >&5
12023	<
12024	<	eval "$as_ac_var=no"
12025	<	fi
12026	<
12027	<	rm -rf conftest.dSYM
12028	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12029	<	conftest$ac_exeext conftest.$ac_ext
12030	<	fi
12031	<	ac_res=`eval 'as_val=${'$as_ac_var'}
12032	<	$as_echo "$as_val"'`
12033	<	{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
12034	<	$as_echo "$ac_res" >&6; }
12035	<	if test `eval 'as_val=${'$as_ac_var'}
12036	<	$as_echo "$as_val"'` = yes; then
10256	>	do :
10257	>	as_ac_var=`$as_echo "ac_cv_func_$ac_func" \| $as_tr_sh`
10258	>	ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
10259	>	eval as_val=\$$as_ac_var
10260	>	if test "x$as_val" = x""yes; then :
10261		cat >>confdefs.h <<_ACEOF
10262		#define `$as_echo "HAVE_$ac_func" \| $as_tr_cpp` 1
10263		_ACEOF
#	Line 12044 \| Line 10268 \| done
10268
10269		# special check for _system_configuration because AIX <4.3.2 do not
10270		# contain the `physmem' member.
10271	<	{ $as_echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
10271	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for external symbol _system_configuration" >&5
10272		$as_echo_n "checking for external symbol _system_configuration... " >&6; }
10273	<	cat >conftest.$ac_ext <<_ACEOF
12050	<	/* confdefs.h. */
12051	<	_ACEOF
12052	<	cat confdefs.h >>conftest.$ac_ext
12053	<	cat >>conftest.$ac_ext <<_ACEOF
10273	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10274		/* end confdefs.h. */
10275		#include <sys/systemcfg.h>
10276		#ifdef FC_DUMMY_MAIN
#	Line 12069 \| Line 10289 \| _ACEOF
10289		return 0;
10290		}
10291		_ACEOF
10292	<	rm -f conftest.$ac_objext
10293	<	if { (ac_try="$ac_compile"
12074	<	case "(($ac_try" in
12075	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
12076	<	*) ac_try_echo=$ac_try;;
12077	<	esac
12078	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12079	<	$as_echo "$ac_try_echo") >&5
12080	<	(eval "$ac_compile") 2>conftest.er1
12081	<	ac_status=$?
12082	<	grep -v '^ *+' conftest.er1 >conftest.err
12083	<	rm -f conftest.er1
12084	<	cat conftest.err >&5
12085	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12086	<	(exit $ac_status); } && {
12087	<	test -z "$ac_c_werror_flag" \|\|
12088	<	test ! -s conftest.err
12089	<	} && test -s conftest.$ac_objext; then
12090	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
10292	>	if ac_fn_c_try_compile "$LINENO"; then :
10293	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
10294		$as_echo "yes" >&6; }
10295
10296	<	cat >>confdefs.h <<\_ACEOF
12094	<	#define HAVE__SYSTEM_CONFIGURATION 1
12095	<	_ACEOF
10296	>	$as_echo "#define HAVE__SYSTEM_CONFIGURATION 1" >>confdefs.h
10297
10298		else
10299	<	$as_echo "$as_me: failed program was:" >&5
12099	<	sed 's/^/\| /' conftest.$ac_ext >&5
12100	<
12101	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
10299	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10300		$as_echo "no" >&6; }
10301		fi
12104	–
10302		rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10303
10304
#	Line 12164 \| Line 10361 \| if test "$ac_test_FFLAGS" != "set"; then
10361		fi
10362
10363
10364	<	{ $as_echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
10364	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${FC} accepts ${FCFLAGS}" >&5
10365		$as_echo_n "checking whether ${FC} accepts ${FCFLAGS}... " >&6; }
10366	<	if test "${ac_guessed_f90flags+set}" = set; then
10366	>	if test "${ac_cv_ac_cv_guessed_f90flags+set}" = set; then :
10367		$as_echo_n "(cached) " >&6
10368		else
10369
#	Line 12179 \| Line 10376 \| ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCE
10376		echo 'program main' > conftest.$ac_ext
10377		echo 'end program main' >> conftest.$ac_ext
10378		ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
10379	<	if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10379	>	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
10380		(eval $ac_compile) 2>&5
10381		ac_status=$?
10382	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10383	<	(exit $ac_status); }; then
10384	<	ac_guessed_f90flags=yes
10382	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
10383	>	test $ac_status = 0; }; then
10384	>	ac_cv_ac_cv_guessed_f90flags=yes
10385		else
10386	<	ac_guessed_f90flags=no
10386	>	ac_cv_ac_cv_guessed_f90flags=no
10387		fi
10388		rm -f conftest*
10389		ac_ext=c
#	Line 12197 \| Line 10394 \| fi
10394
10395
10396		fi
10397	<	{ $as_echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
10398	<	$as_echo "$ac_guessed_f90flags" >&6; }
10399	<	if test "$ac_guessed_f90flags" = yes; then
10397	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_f90flags" >&5
10398	>	$as_echo "$ac_cv_ac_cv_guessed_f90flags" >&6; }
10399	>	if test "$ac_cv_ac_cv_guessed_f90flags" = yes; then
10400		:
10401
10402		else
#	Line 12225 \| Line 10422 \| fi
10422
10423
10424
10425	<	{ $as_echo "$as_me:$LINENO: checking whether we are really using GNU cc" >&5
10425	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are really using GNU cc" >&5
10426		$as_echo_n "checking whether we are really using GNU cc... " >&6; }
10427	<	if test "${ac_cv_prog_really_gcc+set}" = set; then
10427	>	if test "${ac_cv_prog_really_gcc+set}" = set; then :
10428		$as_echo_n "(cached) " >&6
10429		else
10430
#	Line 12241 \| Line 10438 \| if { ac_try='${CC-cc} -E conftest.c'
10438		#endif
10439		EOF
10440		if { ac_try='${CC-cc} -E conftest.c'
10441	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10441	>	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
10442		(eval $ac_try) 2>&5
10443		ac_status=$?
10444	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10445	<	(exit $ac_status); }; } \| egrep yes >/dev/null 2>&1; then
10444	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
10445	>	test $ac_status = 0; }; } \| egrep yes >/dev/null 2>&1; then
10446		ac_cv_prog_really_gcc=yes
10447		else
10448		ac_cv_prog_really_gcc=no
10449		fi
10450
10451		fi
10452	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
10452	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gcc" >&5
10453		$as_echo "$ac_cv_prog_really_gcc" >&6; }
10454		if test "$ac_cv_prog_really_gcc" = yes; then
10455		:
#	Line 12330 \| Line 10527 \| if test "$ac_test_CFLAGS" != "set"; then
10527
10528
10529
10530	<	{ $as_echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
10530	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts ${CFLAGS}" >&5
10531		$as_echo_n "checking whether ${CC} accepts ${CFLAGS}... " >&6; }
10532	<	if test "${ac_guessed_cflags+set}" = set; then
10532	>	if test "${ac_cv_ac_cv_guessed_cflags+set}" = set; then :
10533		$as_echo_n "(cached) " >&6
10534		else
10535		echo 'void f(){}' > conftest.c
10536		if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
10537	<	ac_guessed_cflags=yes
10537	>	ac_cv_ac_cv_guessed_cflags=yes
10538		else
10539	<	ac_guessed_cflags=no
10539	>	ac_cv_ac_cv_guessed_cflags=no
10540		fi
10541		rm -f conftest*
10542
10543		fi
10544	<	{ $as_echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
10545	<	$as_echo "$ac_guessed_cflags" >&6; }
10546	<	if test "$ac_guessed_cflags" = yes; then
10544	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cflags" >&5
10545	>	$as_echo "$ac_cv_ac_cv_guessed_cflags" >&6; }
10546	>	if test "$ac_cv_ac_cv_guessed_cflags" = yes; then
10547		:
10548
10549		else
#	Line 12372 \| Line 10569 \| fi
10569
10570
10571
10572	<	{ $as_echo "$as_me:$LINENO: checking whether we are really using GNU c++" >&5
10572	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are really using GNU c++" >&5
10573		$as_echo_n "checking whether we are really using GNU c++... " >&6; }
10574	<	if test "${ac_cv_prog_really_gxx+set}" = set; then
10574	>	if test "${ac_cv_prog_really_gxx+set}" = set; then :
10575		$as_echo_n "(cached) " >&6
10576		else
10577
#	Line 12388 \| Line 10585 \| if { ac_try='${CXX-c++} -E conftest.cpp'
10585		#endif
10586		EOF
10587		if { ac_try='${CXX-c++} -E conftest.cpp'
10588	<	{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10588	>	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
10589		(eval $ac_try) 2>&5
10590		ac_status=$?
10591	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10592	<	(exit $ac_status); }; } \| egrep yes >/dev/null 2>&1; then
10591	>	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
10592	>	test $ac_status = 0; }; } \| egrep yes >/dev/null 2>&1; then
10593		ac_cv_prog_really_gxx=yes
10594		else
10595		ac_cv_prog_really_gxx=no
10596		fi
10597
10598		fi
10599	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
10599	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gxx" >&5
10600		$as_echo "$ac_cv_prog_really_gxx" >&6; }
10601		if test "$ac_cv_prog_really_gxx" = yes; then
10602		:
#	Line 12468 \| Line 10665 \| if test "$ac_test_CXXFLAGS" != "set"; then
10665
10666
10667
10668	<	{ $as_echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
10668	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
10669		$as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
10670	<	if test "${ac_guessed_cxxflags+set}" = set; then
10670	>	if test "${ac_cv_ac_cv_guessed_cxxflags+set}" = set; then :
10671		$as_echo_n "(cached) " >&6
10672		else
10673		echo 'void f(){}' > conftest.cpp
10674		if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
10675	<	ac_guessed_cxxflags=yes
10675	>	ac_cv_ac_cv_guessed_cxxflags=yes
10676		else
10677	<	ac_guessed_cxxflags=no
10677	>	ac_cv_ac_cv_guessed_cxxflags=no
10678		fi
10679		rm -f conftest*
10680
10681		fi
10682	<	{ $as_echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
10683	<	$as_echo "$ac_guessed_cxxflags" >&6; }
10684	<	if test "$ac_guessed_cxxflags" = yes; then
10682	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cxxflags" >&5
10683	>	$as_echo "$ac_cv_ac_cv_guessed_cxxflags" >&6; }
10684	>	if test "$ac_cv_ac_cv_guessed_cxxflags" = yes; then
10685		:
10686
10687		else
#	Line 12511 \| Line 10708 \| acx_cgal_found=no
10708		acx_cgal_found=no
10709
10710		# Check whether --with-cgalmakefile was given.
10711	<	if test "${with_cgalmakefile+set}" = set; then
10711	>	if test "${with_cgalmakefile+set}" = set; then :
10712		withval=$with_cgalmakefile;
10713		fi
10714
#	Line 12523 \| Line 10720 \| if test "$acx_cgal_found" == no; then
10720		esac
10721
10722		if test "$acx_cgal_found" == no; then
10723	<	{ $as_echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
10723	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking CGAL_MAKEFILE" >&5
10724		$as_echo_n "checking CGAL_MAKEFILE... " >&6; }
10725
10726		if test \! -z "$CGAL_MAKEFILE"; then
#	Line 12534 \| Line 10731 \| include $CGAL_MAKEFILE
10731		cat > $tname << _ACEOF
10732		include $CGAL_MAKEFILE
10733
10734	<	cppflags:
10735	<	@echo \$(CGAL_CXXFLAGS)
12539	<
12540	<	cxxflags:
12541	<	@echo
12542	<	ldflags:
12543	<	@echo \$(CGAL_LDFLAGS)
12544	<	_ACEOF
12545	<	CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
12546	<	CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
12547	<	CGAL_LDFLAGST="`make -s -f $tname ldflags`"
12548	<	for i in $CGAL_LDFLAGST; do
12549	<	if test `echo $i\| grep -c ^-l`; then
12550	<	CGAL_LIBS="$CGAL_LIBS $i"
12551	<	else
12552	<	CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
12553	<	fi
12554	<	done
12555	<	rm -f $tname
12556	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
12557	<	$as_echo "yes" >&6; }
12558	<	acx_cgal_found=yes
12559	<	else
12560	<	{ $as_echo "$as_me:$LINENO: result: invalid" >&5
12561	<	$as_echo "invalid" >&6; }
12562	<	{ { $as_echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
12563	<	$as_echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
12564	<	{ (exit 1); exit 1; }; }
12565	<	fi
12566	<	else
12567	<	{ $as_echo "$as_me:$LINENO: result: not defined" >&5
12568	<	$as_echo "not defined" >&6; }
12569	<	fi
12570	<	fi
12571	<
12572	<	if test "$acx_cgal_found" == no; then
12573	<	if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12574	<	{ $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12575	<	$as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12576	<	if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12577	<	$as_echo_n "(cached) " >&6
12578	<	fi
12579	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12580	<	$as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12581	<	else
12582	<	# Is the header compilable?
12583	<	{ $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
12584	<	$as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... " >&6; }
12585	<	cat >conftest.$ac_ext <<_ACEOF
12586	<	/* confdefs.h. */
12587	<	_ACEOF
12588	<	cat confdefs.h >>conftest.$ac_ext
12589	<	cat >>conftest.$ac_ext <<_ACEOF
12590	<	/* end confdefs.h. */
12591	<	$ac_includes_default
12592	<	#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12593	<	_ACEOF
12594	<	rm -f conftest.$ac_objext
12595	<	if { (ac_try="$ac_compile"
12596	<	case "(($ac_try" in
12597	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
12598	<	*) ac_try_echo=$ac_try;;
12599	<	esac
12600	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12601	<	$as_echo "$ac_try_echo") >&5
12602	<	(eval "$ac_compile") 2>conftest.er1
12603	<	ac_status=$?
12604	<	grep -v '^ *+' conftest.er1 >conftest.err
12605	<	rm -f conftest.er1
12606	<	cat conftest.err >&5
12607	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12608	<	(exit $ac_status); } && {
12609	<	test -z "$ac_c_werror_flag" \|\|
12610	<	test ! -s conftest.err
12611	<	} && test -s conftest.$ac_objext; then
12612	<	ac_header_compiler=yes
12613	<	else
12614	<	$as_echo "$as_me: failed program was:" >&5
12615	<	sed 's/^/\| /' conftest.$ac_ext >&5
12616	<
12617	<	ac_header_compiler=no
12618	<	fi
12619	<
12620	<	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12621	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12622	<	$as_echo "$ac_header_compiler" >&6; }
10734	>	cppflags:
10735	>	@echo \$(CGAL_CXXFLAGS)
10736
10737	<	# Is the header present?
10738	<	{ $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
10739	<	$as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... " >&6; }
10740	<	cat >conftest.$ac_ext <<_ACEOF
12628	<	/* confdefs.h. */
10737	>	cxxflags:
10738	>	@echo
10739	>	ldflags:
10740	>	@echo \$(CGAL_LDFLAGS)
10741		_ACEOF
10742	<	cat confdefs.h >>conftest.$ac_ext
10743	<	cat >>conftest.$ac_ext <<_ACEOF
10744	<	/* end confdefs.h. */
10745	<	#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
10746	<	_ACEOF
10747	<	if { (ac_try="$ac_cpp conftest.$ac_ext"
10748	<	case "(($ac_try" in
10749	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
10750	<	*) ac_try_echo=$ac_try;;
10751	<	esac
10752	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10753	<	$as_echo "$ac_try_echo") >&5
10754	<	(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10755	<	ac_status=$?
10756	<	grep -v '^ *+' conftest.er1 >conftest.err
10757	<	rm -f conftest.er1
10758	<	cat conftest.err >&5
10759	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10760	<	(exit $ac_status); } >/dev/null && {
10761	<	test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" \|\|
10762	<	test ! -s conftest.err
10763	<	}; then
10764	<	ac_header_preproc=yes
12653	<	else
12654	<	$as_echo "$as_me: failed program was:" >&5
12655	<	sed 's/^/\| /' conftest.$ac_ext >&5
12656	<
12657	<	ac_header_preproc=no
10742	>	CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
10743	>	CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
10744	>	CGAL_LDFLAGST="`make -s -f $tname ldflags`"
10745	>	for i in $CGAL_LDFLAGST; do
10746	>	if test `echo $i\| grep -c ^-l`; then
10747	>	CGAL_LIBS="$CGAL_LIBS $i"
10748	>	else
10749	>	CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
10750	>	fi
10751	>	done
10752	>	rm -f $tname
10753	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
10754	>	$as_echo "yes" >&6; }
10755	>	acx_cgal_found=yes
10756	>	else
10757	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: invalid" >&5
10758	>	$as_echo "invalid" >&6; }
10759	>	as_fn_error "CGAL_MAKEFILE defined, but the makefile does not exist." "$LINENO" 5
10760	>	fi
10761	>	else
10762	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not defined" >&5
10763	>	$as_echo "not defined" >&6; }
10764	>	fi
10765		fi
10766
10767	<	rm -f conftest.err conftest.$ac_ext
10768	<	{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10769	<	$as_echo "$ac_header_preproc" >&6; }
12663	<
12664	<	# So? What about this header?
12665	<	case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12666	<	yes:no: )
12667	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
12668	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
12669	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
12670	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
12671	<	ac_header_preproc=yes
12672	<	;;
12673	<	no:yes:* )
12674	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
12675	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
12676	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: check for missing prerequisite headers?" >&5
12677	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: check for missing prerequisite headers?" >&2;}
12678	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
12679	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
12680	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: section \"Present But Cannot Be Compiled\"" >&5
12681	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: section \"Present But Cannot Be Compiled\"" >&2;}
12682	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
12683	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
12684	<	{ $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
12685	<	$as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
12686	<	( cat <<\_ASBOX
12687	<	## ------------------------------ ##
12688	<	## Report this to gezelter@nd.edu ##
12689	<	## ------------------------------ ##
12690	<	_ASBOX
12691	<	) \| sed "s/^/$as_me: WARNING: /" >&2
12692	<	;;
12693	<	esac
12694	<	{ $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12695	<	$as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12696	<	if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12697	<	$as_echo_n "(cached) " >&6
12698	<	else
12699	<	ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
12700	<	fi
12701	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12702	<	$as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12703	<
12704	<	fi
12705	<	if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
10767	>	if test "$acx_cgal_found" == no; then
10768	>	ac_fn_c_check_header_mongrel "$LINENO" "CGAL/Exact_predicates_inexact_constructions_kernel.h" "ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" "$ac_includes_default"
10769	>	if test "x$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" = x""yes; then :
10770		cgal_have_header=yes
10771		else
10772		cgal_have_header=no
#	Line 12710 \| Line 10774 \| fi
10774
10775
10776		if test "$cgal_have_header" == yes; then
10777	<	{ $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
10777	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lCGAL" >&5
10778		$as_echo_n "checking for main in -lCGAL... " >&6; }
10779	<	if test "${ac_cv_lib_CGAL_main+set}" = set; then
10779	>	if test "${ac_cv_lib_CGAL_main+set}" = set; then :
10780		$as_echo_n "(cached) " >&6
10781		else
10782		ac_check_lib_save_LIBS=$LIBS
10783		LIBS="-lCGAL $LIBS"
10784	<	cat >conftest.$ac_ext <<_ACEOF
12721	<	/* confdefs.h. */
12722	<	_ACEOF
12723	<	cat confdefs.h >>conftest.$ac_ext
12724	<	cat >>conftest.$ac_ext <<_ACEOF
10784	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10785		/* end confdefs.h. */
10786
10787
#	Line 12741 \| Line 10801 \| _ACEOF
10801		return 0;
10802		}
10803		_ACEOF
10804	<	rm -f conftest.$ac_objext conftest$ac_exeext
12745	<	if { (ac_try="$ac_link"
12746	<	case "(($ac_try" in
12747	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
12748	<	*) ac_try_echo=$ac_try;;
12749	<	esac
12750	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12751	<	$as_echo "$ac_try_echo") >&5
12752	<	(eval "$ac_link") 2>conftest.er1
12753	<	ac_status=$?
12754	<	grep -v '^ *+' conftest.er1 >conftest.err
12755	<	rm -f conftest.er1
12756	<	cat conftest.err >&5
12757	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12758	<	(exit $ac_status); } && {
12759	<	test -z "$ac_c_werror_flag" \|\|
12760	<	test ! -s conftest.err
12761	<	} && test -s conftest$ac_exeext && {
12762	<	test "$cross_compiling" = yes \|\|
12763	<	$as_test_x conftest$ac_exeext
12764	<	}; then
10804	>	if ac_fn_c_try_link "$LINENO"; then :
10805		ac_cv_lib_CGAL_main=yes
10806		else
10807	<	$as_echo "$as_me: failed program was:" >&5
12768	<	sed 's/^/\| /' conftest.$ac_ext >&5
12769	<
12770	<	ac_cv_lib_CGAL_main=no
10807	>	ac_cv_lib_CGAL_main=no
10808		fi
10809	<
10810	<	rm -rf conftest.dSYM
12774	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12775	<	conftest$ac_exeext conftest.$ac_ext
10809	>	rm -f core conftest.err conftest.$ac_objext \
10810	>	conftest$ac_exeext conftest.$ac_ext
10811		LIBS=$ac_check_lib_save_LIBS
10812		fi
10813	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
10813	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_CGAL_main" >&5
10814		$as_echo "$ac_cv_lib_CGAL_main" >&6; }
10815	<	if test $ac_cv_lib_CGAL_main = yes; then
10815	>	if test "x$ac_cv_lib_CGAL_main" = x""yes; then :
10816		cgal_have_lib=yes
10817		else
10818		cgal_have_lib=no
#	Line 12785 \| Line 10820 \| fi
10820
10821		if test "$cgal_have_lib" == no; then
10822		save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
10823	<	{ $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
10823	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lCGAL" >&5
10824		$as_echo_n "checking for main in -lCGAL... " >&6; }
10825	<	if test "${ac_cv_lib_CGAL_main+set}" = set; then
10825	>	if test "${ac_cv_lib_CGAL_main+set}" = set; then :
10826		$as_echo_n "(cached) " >&6
10827		else
10828		ac_check_lib_save_LIBS=$LIBS
10829		LIBS="-lCGAL $LIBS"
10830	<	cat >conftest.$ac_ext <<_ACEOF
12796	<	/* confdefs.h. */
12797	<	_ACEOF
12798	<	cat confdefs.h >>conftest.$ac_ext
12799	<	cat >>conftest.$ac_ext <<_ACEOF
10830	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10831		/* end confdefs.h. */
10832
10833
#	Line 12816 \| Line 10847 \| _ACEOF
10847		return 0;
10848		}
10849		_ACEOF
10850	<	rm -f conftest.$ac_objext conftest$ac_exeext
12820	<	if { (ac_try="$ac_link"
12821	<	case "(($ac_try" in
12822	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
12823	<	*) ac_try_echo=$ac_try;;
12824	<	esac
12825	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12826	<	$as_echo "$ac_try_echo") >&5
12827	<	(eval "$ac_link") 2>conftest.er1
12828	<	ac_status=$?
12829	<	grep -v '^ *+' conftest.er1 >conftest.err
12830	<	rm -f conftest.er1
12831	<	cat conftest.err >&5
12832	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12833	<	(exit $ac_status); } && {
12834	<	test -z "$ac_c_werror_flag" \|\|
12835	<	test ! -s conftest.err
12836	<	} && test -s conftest$ac_exeext && {
12837	<	test "$cross_compiling" = yes \|\|
12838	<	$as_test_x conftest$ac_exeext
12839	<	}; then
10850	>	if ac_fn_c_try_link "$LINENO"; then :
10851		ac_cv_lib_CGAL_main=yes
10852		else
10853	<	$as_echo "$as_me: failed program was:" >&5
12843	<	sed 's/^/\| /' conftest.$ac_ext >&5
12844	<
12845	<	ac_cv_lib_CGAL_main=no
10853	>	ac_cv_lib_CGAL_main=no
10854		fi
10855	<
10856	<	rm -rf conftest.dSYM
12849	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12850	<	conftest$ac_exeext conftest.$ac_ext
10855	>	rm -f core conftest.err conftest.$ac_objext \
10856	>	conftest$ac_exeext conftest.$ac_ext
10857		LIBS=$ac_check_lib_save_LIBS
10858		fi
10859	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
10859	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_CGAL_main" >&5
10860		$as_echo "$ac_cv_lib_CGAL_main" >&6; }
10861	<	if test $ac_cv_lib_CGAL_main = yes; then
10861	>	if test "x$ac_cv_lib_CGAL_main" = x""yes; then :
10862		CGAL_LIBS="-lCGAL -lgmp -lmpfr"
10863		cgal_have_lib=yes
10864		else
#	Line 12862 \| Line 10868 \| fi
10868		LIBS="$save_LIBS"
10869		else
10870		CGAL_LIBS="-lCGAL"
10871	<	{ $as_echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
10871	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lmpfr" >&5
10872		$as_echo_n "checking for main in -lmpfr... " >&6; }
10873	<	if test "${ac_cv_lib_mpfr_main+set}" = set; then
10873	>	if test "${ac_cv_lib_mpfr_main+set}" = set; then :
10874		$as_echo_n "(cached) " >&6
10875		else
10876		ac_check_lib_save_LIBS=$LIBS
10877		LIBS="-lmpfr $LIBS"
10878	<	cat >conftest.$ac_ext <<_ACEOF
12873	<	/* confdefs.h. */
12874	<	_ACEOF
12875	<	cat confdefs.h >>conftest.$ac_ext
12876	<	cat >>conftest.$ac_ext <<_ACEOF
10878	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10879		/* end confdefs.h. */
10880
10881
#	Line 12893 \| Line 10895 \| _ACEOF
10895		return 0;
10896		}
10897		_ACEOF
10898	<	rm -f conftest.$ac_objext conftest$ac_exeext
12897	<	if { (ac_try="$ac_link"
12898	<	case "(($ac_try" in
12899	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
12900	<	*) ac_try_echo=$ac_try;;
12901	<	esac
12902	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12903	<	$as_echo "$ac_try_echo") >&5
12904	<	(eval "$ac_link") 2>conftest.er1
12905	<	ac_status=$?
12906	<	grep -v '^ *+' conftest.er1 >conftest.err
12907	<	rm -f conftest.er1
12908	<	cat conftest.err >&5
12909	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12910	<	(exit $ac_status); } && {
12911	<	test -z "$ac_c_werror_flag" \|\|
12912	<	test ! -s conftest.err
12913	<	} && test -s conftest$ac_exeext && {
12914	<	test "$cross_compiling" = yes \|\|
12915	<	$as_test_x conftest$ac_exeext
12916	<	}; then
10898	>	if ac_fn_c_try_link "$LINENO"; then :
10899		ac_cv_lib_mpfr_main=yes
10900		else
10901	<	$as_echo "$as_me: failed program was:" >&5
12920	<	sed 's/^/\| /' conftest.$ac_ext >&5
12921	<
12922	<	ac_cv_lib_mpfr_main=no
10901	>	ac_cv_lib_mpfr_main=no
10902		fi
10903	<
10904	<	rm -rf conftest.dSYM
12926	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12927	<	conftest$ac_exeext conftest.$ac_ext
10903	>	rm -f core conftest.err conftest.$ac_objext \
10904	>	conftest$ac_exeext conftest.$ac_ext
10905		LIBS=$ac_check_lib_save_LIBS
10906		fi
10907	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
10907	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpfr_main" >&5
10908		$as_echo "$ac_cv_lib_mpfr_main" >&6; }
10909	<	if test $ac_cv_lib_mpfr_main = yes; then
10909	>	if test "x$ac_cv_lib_mpfr_main" = x""yes; then :
10910		CGAL_LIBS="$CGAL_LIBS -lmpfr"
10911		fi
10912
10913	<	{ $as_echo "$as_me:$LINENO: checking for main in -lgmp" >&5
10913	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lgmp" >&5
10914		$as_echo_n "checking for main in -lgmp... " >&6; }
10915	<	if test "${ac_cv_lib_gmp_main+set}" = set; then
10915	>	if test "${ac_cv_lib_gmp_main+set}" = set; then :
10916		$as_echo_n "(cached) " >&6
10917		else
10918		ac_check_lib_save_LIBS=$LIBS
10919		LIBS="-lgmp $LIBS"
10920	<	cat >conftest.$ac_ext <<_ACEOF
12944	<	/* confdefs.h. */
12945	<	_ACEOF
12946	<	cat confdefs.h >>conftest.$ac_ext
12947	<	cat >>conftest.$ac_ext <<_ACEOF
10920	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10921		/* end confdefs.h. */
10922
10923
#	Line 12964 \| Line 10937 \| _ACEOF
10937		return 0;
10938		}
10939		_ACEOF
10940	<	rm -f conftest.$ac_objext conftest$ac_exeext
12968	<	if { (ac_try="$ac_link"
12969	<	case "(($ac_try" in
12970	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
12971	<	*) ac_try_echo=$ac_try;;
12972	<	esac
12973	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12974	<	$as_echo "$ac_try_echo") >&5
12975	<	(eval "$ac_link") 2>conftest.er1
12976	<	ac_status=$?
12977	<	grep -v '^ *+' conftest.er1 >conftest.err
12978	<	rm -f conftest.er1
12979	<	cat conftest.err >&5
12980	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12981	<	(exit $ac_status); } && {
12982	<	test -z "$ac_c_werror_flag" \|\|
12983	<	test ! -s conftest.err
12984	<	} && test -s conftest$ac_exeext && {
12985	<	test "$cross_compiling" = yes \|\|
12986	<	$as_test_x conftest$ac_exeext
12987	<	}; then
10940	>	if ac_fn_c_try_link "$LINENO"; then :
10941		ac_cv_lib_gmp_main=yes
10942		else
10943	<	$as_echo "$as_me: failed program was:" >&5
12991	<	sed 's/^/\| /' conftest.$ac_ext >&5
12992	<
12993	<	ac_cv_lib_gmp_main=no
10943	>	ac_cv_lib_gmp_main=no
10944		fi
10945	<
10946	<	rm -rf conftest.dSYM
12997	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12998	<	conftest$ac_exeext conftest.$ac_ext
10945	>	rm -f core conftest.err conftest.$ac_objext \
10946	>	conftest$ac_exeext conftest.$ac_ext
10947		LIBS=$ac_check_lib_save_LIBS
10948		fi
10949	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
10949	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gmp_main" >&5
10950		$as_echo "$ac_cv_lib_gmp_main" >&6; }
10951	<	if test $ac_cv_lib_gmp_main = yes; then
10951	>	if test "x$ac_cv_lib_gmp_main" = x""yes; then :
10952		CGAL_LIBS="$CGAL_LIBS -lgmp"
10953		fi
10954
10955	<	{ $as_echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
10955	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lgmpxx" >&5
10956		$as_echo_n "checking for main in -lgmpxx... " >&6; }
10957	<	if test "${ac_cv_lib_gmpxx_main+set}" = set; then
10957	>	if test "${ac_cv_lib_gmpxx_main+set}" = set; then :
10958		$as_echo_n "(cached) " >&6
10959		else
10960		ac_check_lib_save_LIBS=$LIBS
10961		LIBS="-lgmpxx $LIBS"
10962	<	cat >conftest.$ac_ext <<_ACEOF
13015	<	/* confdefs.h. */
13016	<	_ACEOF
13017	<	cat confdefs.h >>conftest.$ac_ext
13018	<	cat >>conftest.$ac_ext <<_ACEOF
10962	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10963		/* end confdefs.h. */
10964
10965
#	Line 13035 \| Line 10979 \| _ACEOF
10979		return 0;
10980		}
10981		_ACEOF
10982	<	rm -f conftest.$ac_objext conftest$ac_exeext
13039	<	if { (ac_try="$ac_link"
13040	<	case "(($ac_try" in
13041	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
13042	<	*) ac_try_echo=$ac_try;;
13043	<	esac
13044	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13045	<	$as_echo "$ac_try_echo") >&5
13046	<	(eval "$ac_link") 2>conftest.er1
13047	<	ac_status=$?
13048	<	grep -v '^ *+' conftest.er1 >conftest.err
13049	<	rm -f conftest.er1
13050	<	cat conftest.err >&5
13051	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13052	<	(exit $ac_status); } && {
13053	<	test -z "$ac_c_werror_flag" \|\|
13054	<	test ! -s conftest.err
13055	<	} && test -s conftest$ac_exeext && {
13056	<	test "$cross_compiling" = yes \|\|
13057	<	$as_test_x conftest$ac_exeext
13058	<	}; then
10982	>	if ac_fn_c_try_link "$LINENO"; then :
10983		ac_cv_lib_gmpxx_main=yes
10984		else
10985	<	$as_echo "$as_me: failed program was:" >&5
13062	<	sed 's/^/\| /' conftest.$ac_ext >&5
13063	<
13064	<	ac_cv_lib_gmpxx_main=no
10985	>	ac_cv_lib_gmpxx_main=no
10986		fi
10987	<
10988	<	rm -rf conftest.dSYM
13068	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13069	<	conftest$ac_exeext conftest.$ac_ext
10987	>	rm -f core conftest.err conftest.$ac_objext \
10988	>	conftest$ac_exeext conftest.$ac_ext
10989		LIBS=$ac_check_lib_save_LIBS
10990		fi
10991	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
10991	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gmpxx_main" >&5
10992		$as_echo "$ac_cv_lib_gmpxx_main" >&6; }
10993	<	if test $ac_cv_lib_gmpxx_main = yes; then
10993	>	if test "x$ac_cv_lib_gmpxx_main" = x""yes; then :
10994		CGAL_LIBS="$CGAL_LIBS -lgmpxx"
10995		fi
10996
#	Line 13082 \| Line 11001 \| fi
11001		fi
11002		fi
11003		if test "$acx_cgal_found" == yes; then
11004	<	{ $as_echo "$as_me:$LINENO: checking for main in -lCore" >&5
11004	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lCore" >&5
11005		$as_echo_n "checking for main in -lCore... " >&6; }
11006	<	if test "${ac_cv_lib_Core_main+set}" = set; then
11006	>	if test "${ac_cv_lib_Core_main+set}" = set; then :
11007		$as_echo_n "(cached) " >&6
11008		else
11009		ac_check_lib_save_LIBS=$LIBS
11010		LIBS="-lCore $LIBS"
11011	<	cat >conftest.$ac_ext <<_ACEOF
13093	<	/* confdefs.h. */
13094	<	_ACEOF
13095	<	cat confdefs.h >>conftest.$ac_ext
13096	<	cat >>conftest.$ac_ext <<_ACEOF
11011	>	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11012		/* end confdefs.h. */
11013
11014
#	Line 13113 \| Line 11028 \| _ACEOF
11028		return 0;
11029		}
11030		_ACEOF
11031	<	rm -f conftest.$ac_objext conftest$ac_exeext
13117	<	if { (ac_try="$ac_link"
13118	<	case "(($ac_try" in
13119	<	\" \| \` \| \\) ac_try_echo=\$ac_try;;
13120	<	*) ac_try_echo=$ac_try;;
13121	<	esac
13122	<	eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13123	<	$as_echo "$ac_try_echo") >&5
13124	<	(eval "$ac_link") 2>conftest.er1
13125	<	ac_status=$?
13126	<	grep -v '^ *+' conftest.er1 >conftest.err
13127	<	rm -f conftest.er1
13128	<	cat conftest.err >&5
13129	<	$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13130	<	(exit $ac_status); } && {
13131	<	test -z "$ac_c_werror_flag" \|\|
13132	<	test ! -s conftest.err
13133	<	} && test -s conftest$ac_exeext && {
13134	<	test "$cross_compiling" = yes \|\|
13135	<	$as_test_x conftest$ac_exeext
13136	<	}; then
11031	>	if ac_fn_c_try_link "$LINENO"; then :
11032		ac_cv_lib_Core_main=yes
11033		else
11034	<	$as_echo "$as_me: failed program was:" >&5
13140	<	sed 's/^/\| /' conftest.$ac_ext >&5
13141	<
13142	<	ac_cv_lib_Core_main=no
11034	>	ac_cv_lib_Core_main=no
11035		fi
11036	<
11037	<	rm -rf conftest.dSYM
13146	<	rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13147	<	conftest$ac_exeext conftest.$ac_ext
11036	>	rm -f core conftest.err conftest.$ac_objext \
11037	>	conftest$ac_exeext conftest.$ac_ext
11038		LIBS=$ac_check_lib_save_LIBS
11039		fi
11040	<	{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
11040	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Core_main" >&5
11041		$as_echo "$ac_cv_lib_Core_main" >&6; }
11042	<	if test $ac_cv_lib_Core_main = yes; then
11042	>	if test "x$ac_cv_lib_Core_main" = x""yes; then :
11043		CGAL_LIBS="$CGAL_LIBS -lCore"
11044		fi
11045
#	Line 13158 \| Line 11048 \| fi
11048
11049
11050
11051	<	{ $as_echo "$as_me:$LINENO: checking CGAL" >&5
11051	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking CGAL" >&5
11052		$as_echo_n "checking CGAL... " >&6; }
11053
11054
#	Line 13166 \| Line 11056 \| if test "$acx_cgal_found" == yes; then
11056
11057
11058		if test "$acx_cgal_found" == yes; then
11059	<	{ $as_echo "$as_me:$LINENO: result: yes" >&5
11059	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
11060		$as_echo "yes" >&6; }
11061
11062		else
11063	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
11063	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11064		$as_echo "no" >&6; }
11065
11066		fi
#	Line 13178 \| Line 11068 \| if test "$acx_cgal_found" == yes; then
11068		if test "$acx_cgal_found" == yes; then
11069		USE_CGAL=yes
11070
11071	<	cat >>confdefs.h <<\_ACEOF
13182	<	#define HAVE_CGAL 1
13183	<	_ACEOF
11071	>	$as_echo "#define HAVE_CGAL 1" >>confdefs.h
11072
11073
11074
#	Line 13192 \| Line 11080 \| fi
11080
11081
11082		# Check whether --enable-doxygen was given.
11083	<	if test "${enable_doxygen+set}" = set; then
11083	>	if test "${enable_doxygen+set}" = set; then :
11084		enableval=$enable_doxygen;
11085		fi
11086
11087		# Check whether --enable-dot was given.
11088	<	if test "${enable_dot+set}" = set; then
11088	>	if test "${enable_dot+set}" = set; then :
11089		enableval=$enable_dot;
11090		fi
11091
11092		# Check whether --enable-html-docs was given.
11093	<	if test "${enable_html_docs+set}" = set; then
11093	>	if test "${enable_html_docs+set}" = set; then :
11094		enableval=$enable_html_docs;
11095		else
11096		enable_html_docs=yes
11097		fi
11098
11099		# Check whether --enable-latex-docs was given.
11100	<	if test "${enable_latex_docs+set}" = set; then
11100	>	if test "${enable_latex_docs+set}" = set; then :
11101		enableval=$enable_latex_docs;
11102		else
11103		enable_latex_docs=no
#	Line 13220 \| Line 11108 \| set dummy doxygen; ac_word=$2
11108		else
11109		# Extract the first word of "doxygen", so it can be a program name with args.
11110		set dummy doxygen; ac_word=$2
11111	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
11111	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11112		$as_echo_n "checking for $ac_word... " >&6; }
11113	<	if test "${ac_cv_path_DOXYGEN+set}" = set; then
11113	>	if test "${ac_cv_path_DOXYGEN+set}" = set; then :
11114		$as_echo_n "(cached) " >&6
11115		else
11116		case $DOXYGEN in
#	Line 13235 \| Line 11123 \| do
11123		do
11124		IFS=$as_save_IFS
11125		test -z "$as_dir" && as_dir=.
11126	<	for ac_exec_ext in '' $ac_executable_extensions; do
11126	>	for ac_exec_ext in '' $ac_executable_extensions; do
11127		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
11128		ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
11129	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11129	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11130		break 2
11131		fi
11132		done
11133	<	done
11133	>	done
11134		IFS=$as_save_IFS
11135
11136		;;
#	Line 13250 \| Line 11138 \| if test -n "$DOXYGEN"; then
11138		fi
11139		DOXYGEN=$ac_cv_path_DOXYGEN
11140		if test -n "$DOXYGEN"; then
11141	<	{ $as_echo "$as_me:$LINENO: result: $DOXYGEN" >&5
11141	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOXYGEN" >&5
11142		$as_echo "$DOXYGEN" >&6; }
11143		else
11144	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
11144	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11145		$as_echo "no" >&6; }
11146		fi
11147
11148
11149		if test "x$DOXYGEN" = x; then
11150		if test "x$enable_doxygen" = xyes; then
11151	<	{ { $as_echo "$as_me:$LINENO: error: could not find doxygen" >&5
13264	<	$as_echo "$as_me: error: could not find doxygen" >&2;}
13265	<	{ (exit 1); exit 1; }; }
11151	>	as_fn_error "could not find doxygen" "$LINENO" 5
11152		fi
11153		enable_doc=no
11154		else
11155		enable_doc=yes
11156		# Extract the first word of "dot", so it can be a program name with args.
11157		set dummy dot; ac_word=$2
11158	<	{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
11158	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11159		$as_echo_n "checking for $ac_word... " >&6; }
11160	<	if test "${ac_cv_path_DOT+set}" = set; then
11160	>	if test "${ac_cv_path_DOT+set}" = set; then :
11161		$as_echo_n "(cached) " >&6
11162		else
11163		case $DOT in
#	Line 13284 \| Line 11170 \| do
11170		do
11171		IFS=$as_save_IFS
11172		test -z "$as_dir" && as_dir=.
11173	<	for ac_exec_ext in '' $ac_executable_extensions; do
11173	>	for ac_exec_ext in '' $ac_executable_extensions; do
11174		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
11175		ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
11176	<	$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11176	>	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11177		break 2
11178		fi
11179		done
11180	<	done
11180	>	done
11181		IFS=$as_save_IFS
11182
11183		;;
#	Line 13299 \| Line 11185 \| if test -n "$DOT"; then
11185		fi
11186		DOT=$ac_cv_path_DOT
11187		if test -n "$DOT"; then
11188	<	{ $as_echo "$as_me:$LINENO: result: $DOT" >&5
11188	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
11189		$as_echo "$DOT" >&6; }
11190		else
11191	<	{ $as_echo "$as_me:$LINENO: result: no" >&5
11191	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11192		$as_echo "no" >&6; }
11193		fi
11194
#	Line 13319 \| Line 11205 \| if test x$DOT = x; then
11205
11206		if test x$DOT = x; then
11207		if test "x$enable_dot" = xyes; then
11208	<	{ { $as_echo "$as_me:$LINENO: error: could not find dot" >&5
13323	<	$as_echo "$as_me: error: could not find dot" >&2;}
13324	<	{ (exit 1); exit 1; }; }
11208	>	as_fn_error "could not find dot" "$LINENO" 5
11209		fi
11210		enable_dot=no
11211		else
#	Line 13376 \| Line 11260 \| _ACEOF
11260		case $ac_val in #(
11261		${as_nl})
11262		case $ac_var in #(
11263	<	_cv_) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
11264	<	$as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
11263	>	_cv_) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
11264	>	$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
11265		esac
11266		case $ac_var in #(
11267		_ \| IFS \| as_nl) ;; #(
11268		BASH_ARGV \| BASH_SOURCE) eval $ac_var= ;; #(
11269	<	*) $as_unset $ac_var ;;
11269	>	*) { eval $ac_var=; unset $ac_var;} ;;
11270		esac ;;
11271		esac
11272		done
#	Line 13390 \| Line 11274 \| $as_echo "$as_me: WARNING: Cache variable $ac_var cont
11274		(set) 2>&1 \|
11275		case $as_nl`(ac_space=' '; set) 2>&1` in #(
11276		${as_nl}ac_space=\ )
11277	<	# `set' does not quote correctly, so add quotes (double-quote
11278	<	# substitution turns \\\\ into \\, and sed turns \\ into \).
11277	>	# `set' does not quote correctly, so add quotes: double-quote
11278	>	# substitution turns \\\\ into \\, and sed turns \\ into \.
11279		sed -n \
11280		"s/'/'\\\\''/g;
11281		s/^\$[_$as_cr_alnum]_cv_[_$as_cr_alnum]\$=\$.*\$/\\1='\\2'/p"
#	Line 13414 \| Line 11298 \| if diff "$cache_file" confcache >/dev/null 2>&1; then
11298		if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
11299		if test -w "$cache_file"; then
11300		test "x$cache_file" != "x/dev/null" &&
11301	<	{ $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
11301	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
11302		$as_echo "$as_me: updating cache $cache_file" >&6;}
11303		cat confcache >$cache_file
11304		else
11305	<	{ $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
11305	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
11306		$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
11307		fi
11308		fi
#	Line 13438 \| Line 11322 \| for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && conti
11322		ac_i=`$as_echo "$ac_i" \| sed "$ac_script"`
11323		# 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR
11324		# will be set to the directory where LIBOBJS objects are built.
11325	<	ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
11326	<	ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
11325	>	as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
11326	>	as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
11327		done
11328		LIBOBJS=$ac_libobjs
11329
#	Line 13451 \| Line 11335 \| ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11335		ac_write_fail=0
11336		ac_clean_files_save=$ac_clean_files
11337		ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11338	<	{ $as_echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11338	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
11339		$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
11340	<	cat >$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
11340	>	as_write_fail=0
11341	>	cat >$CONFIG_STATUS <<_ASEOF \|\| as_write_fail=1
11342		#! $SHELL
11343		# Generated by $as_me.
11344		# Run this file to recreate the current configuration.
#	Line 13463 \| Line 11348 \| ac_cs_silent=false
11348		debug=false
11349		ac_cs_recheck=false
11350		ac_cs_silent=false
11351	+
11352		SHELL=\${CONFIG_SHELL-$SHELL}
11353	<	_ACEOF
11353	>	export SHELL
11354	>	_ASEOF
11355	>	cat >>$CONFIG_STATUS <<\_ASEOF \|\| as_write_fail=1
11356	>	## -------------------- ##
11357	>	## M4sh Initialization. ##
11358	>	## -------------------- ##
11359
13469	–	cat >>$CONFIG_STATUS <<\_ACEOF \|\| ac_write_fail=1
13470	–	## --------------------- ##
13471	–	## M4sh Initialization. ##
13472	–	## --------------------- ##
13473	–
11360		# Be more Bourne compatible
11361		DUALCASE=1; export DUALCASE # for MKS sh
11362	<	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11362	>	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
11363		emulate sh
11364		NULLCMD=:
11365		# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
#	Line 13481 \| Line 11367 \| else
11367		alias -g '${1+"$@"}'='"$@"'
11368		setopt NO_GLOB_SUBST
11369		else
11370	<	case `(set -o) 2>/dev/null` in
11371	<	posix) set -o posix ;;
11370	>	case `(set -o) 2>/dev/null` in #(
11371	>	posix) :
11372	>	set -o posix ;; #(
11373	>	*) :
11374	>	;;
11375		esac
13487	–
11376		fi
11377
11378
13491	–
13492	–
13493	–	# PATH needs CR
13494	–	# Avoid depending upon Character Ranges.
13495	–	as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13496	–	as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13497	–	as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13498	–	as_cr_digits='0123456789'
13499	–	as_cr_alnum=$as_cr_Letters$as_cr_digits
13500	–
11379		as_nl='
11380		'
11381		export as_nl
#	Line 13505 \| Line 11383 \| as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_ec
11383		as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
11384		as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
11385		as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
11386	<	if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
11386	>	# Prefer a ksh shell builtin over an external printf program on Solaris,
11387	>	# but without wasting forks for bash or zsh.
11388	>	if test -z "$BASH_VERSION$ZSH_VERSION" \
11389	>	&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
11390	>	as_echo='print -r --'
11391	>	as_echo_n='print -rn --'
11392	>	elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
11393		as_echo='printf %s\n'
11394		as_echo_n='printf %s'
11395		else
#	Line 13516 \| Line 11400 \| else
11400		as_echo_body='eval expr "X$1" : "X\$.*\$"'
11401		as_echo_n_body='eval
11402		arg=$1;
11403	<	case $arg in
11403	>	case $arg in #(
11404		"$as_nl")
11405		expr "X$arg" : "X\$.*\$$as_nl";
11406		arg=`expr "X$arg" : ".$as_nl\$.\$"`;;
#	Line 13539 \| Line 11423 \| fi
11423		}
11424		fi
11425
13542	–	# Support unset when possible.
13543	–	if ( (MAIL=60; unset MAIL) \|\| exit) >/dev/null 2>&1; then
13544	–	as_unset=unset
13545	–	else
13546	–	as_unset=false
13547	–	fi
11426
13549	–
11427		# IFS
11428		# We need space, tab and new line, in precisely that order. Quoting is
11429		# there to prevent editors from complaining about space-tab.
#	Line 13555 \| Line 11432 \| IFS=" "" $as_nl"
11432		IFS=" "" $as_nl"
11433
11434		# Find who we are. Look in the path if we contain no directory separator.
11435	<	case $0 in
11435	>	case $0 in #((
11436		[\\/] ) as_myself=$0 ;;
11437		*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11438		for as_dir in $PATH
11439		do
11440		IFS=$as_save_IFS
11441		test -z "$as_dir" && as_dir=.
11442	<	test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11443	<	done
11442	>	test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11443	>	done
11444		IFS=$as_save_IFS
11445
11446		;;
#	Line 13575 \| Line 11452 \| if test ! -f "$as_myself"; then
11452		fi
11453		if test ! -f "$as_myself"; then
11454		$as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
11455	<	{ (exit 1); exit 1; }
11455	>	exit 1
11456		fi
11457
11458	<	# Work around bugs in pre-3.0 UWIN ksh.
11459	<	for as_var in ENV MAIL MAILPATH
11460	<	do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
11458	>	# Unset variables that we do not need and which cause bugs (e.g. in
11459	>	# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "\|\| exit 1"
11460	>	# suppresses any "Segmentation fault" message there. '((' could
11461	>	# trigger a bug in pdksh 5.2.14.
11462	>	for as_var in BASH_ENV ENV MAIL MAILPATH
11463	>	do eval test x\${$as_var+set} = xset \
11464	>	&& ( (unset $as_var) \|\| exit 1) >/dev/null 2>&1 && unset $as_var \|\| :
11465		done
11466		PS1='$ '
11467		PS2='> '
#	Line 13592 \| Line 11473 \| export LANGUAGE
11473		LANGUAGE=C
11474		export LANGUAGE
11475
11476	<	# Required to use basename.
11476	>	# CDPATH.
11477	>	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
11478	>
11479	>
11480	>	# as_fn_error ERROR [LINENO LOG_FD]
11481	>	# ---------------------------------
11482	>	# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
11483	>	# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
11484	>	# script with status $?, using 1 if that was 0.
11485	>	as_fn_error ()
11486	>	{
11487	>	as_status=$?; test $as_status -eq 0 && as_status=1
11488	>	if test "$3"; then
11489	>	as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
11490	>	$as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
11491	>	fi
11492	>	$as_echo "$as_me: error: $1" >&2
11493	>	as_fn_exit $as_status
11494	>	} # as_fn_error
11495	>
11496	>
11497	>	# as_fn_set_status STATUS
11498	>	# -----------------------
11499	>	# Set $? to STATUS, without forking.
11500	>	as_fn_set_status ()
11501	>	{
11502	>	return $1
11503	>	} # as_fn_set_status
11504	>
11505	>	# as_fn_exit STATUS
11506	>	# -----------------
11507	>	# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
11508	>	as_fn_exit ()
11509	>	{
11510	>	set +e
11511	>	as_fn_set_status $1
11512	>	exit $1
11513	>	} # as_fn_exit
11514	>
11515	>	# as_fn_unset VAR
11516	>	# ---------------
11517	>	# Portably unset VAR.
11518	>	as_fn_unset ()
11519	>	{
11520	>	{ eval $1=; unset $1;}
11521	>	}
11522	>	as_unset=as_fn_unset
11523	>	# as_fn_append VAR VALUE
11524	>	# ----------------------
11525	>	# Append the text in VALUE to the end of the definition contained in VAR. Take
11526	>	# advantage of any shell optimizations that allow amortized linear growth over
11527	>	# repeated appends, instead of the typical quadratic growth present in naive
11528	>	# implementations.
11529	>	if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
11530	>	eval 'as_fn_append ()
11531	>	{
11532	>	eval $1+=\$2
11533	>	}'
11534	>	else
11535	>	as_fn_append ()
11536	>	{
11537	>	eval $1=\$$1\$2
11538	>	}
11539	>	fi # as_fn_append
11540	>
11541	>	# as_fn_arith ARG...
11542	>	# ------------------
11543	>	# Perform arithmetic evaluation on the ARGs, and store the result in the
11544	>	# global $as_val. Take advantage of shells that can avoid forks. The arguments
11545	>	# must be portable across $(()) and expr.
11546	>	if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
11547	>	eval 'as_fn_arith ()
11548	>	{
11549	>	as_val=$(( $* ))
11550	>	}'
11551	>	else
11552	>	as_fn_arith ()
11553	>	{
11554	>	as_val=`expr "$@" \|\| test $? -eq 1`
11555	>	}
11556	>	fi # as_fn_arith
11557	>
11558	>
11559		if expr a : '$a$' >/dev/null 2>&1 &&
11560		test "X`expr 00001 : '.*$...$'`" = X001; then
11561		as_expr=expr
#	Line 13606 \| Line 11569 \| fi
11569		as_basename=false
11570		fi
11571
11572	+	if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
11573	+	as_dirname=dirname
11574	+	else
11575	+	as_dirname=false
11576	+	fi
11577
13610	–	# Name of the executable.
11578		as_me=`$as_basename -- "$0" \|\|
11579		$as_expr X/"$0" : './$[^/][^/]$/*$' \\| \
11580		X"$0" : 'X$//$$' \\| \
#	Line 13627 \| Line 11594 \| $as_echo X/"$0" \|
11594		}
11595		s/.*/./; q'`
11596
11597	<	# CDPATH.
11598	<	$as_unset CDPATH
11597	>	# Avoid depending upon Character Ranges.
11598	>	as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11599	>	as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11600	>	as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11601	>	as_cr_digits='0123456789'
11602	>	as_cr_alnum=$as_cr_Letters$as_cr_digits
11603
13633	–
13634	–
13635	–	as_lineno_1=$LINENO
13636	–	as_lineno_2=$LINENO
13637	–	test "x$as_lineno_1" != "x$as_lineno_2" &&
13638	–	test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" \|\| {
13639	–
13640	–	# Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13641	–	# uniformly replaced by the line number. The first 'sed' inserts a
13642	–	# line-number line after each line using $LINENO; the second 'sed'
13643	–	# does the real work. The second script uses 'N' to pair each
13644	–	# line-number line with the line containing $LINENO, and appends
13645	–	# trailing '-' during substitution so that $LINENO is not a special
13646	–	# case at line end.
13647	–	# (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13648	–	# scripts with optimization help from Paolo Bonzini. Blame Lee
13649	–	# E. McMahon (1931-1989) for sed's syntax. :-)
13650	–	sed -n '
13651	–	p
13652	–	/[$]LINENO/=
13653	–	' <$as_myself \|
13654	–	sed '
13655	–	s/[$]LINENO.*/&-/
13656	–	t lineno
13657	–	b
13658	–	:lineno
13659	–	N
13660	–	:loop
13661	–	s/[$]LINENO$[^'$as_cr_alnum'_].\n$$.$/\2\1\2/
13662	–	t loop
13663	–	s/-\n.*//
13664	–	' >$as_me.lineno &&
13665	–	chmod +x "$as_me.lineno" \|\|
13666	–	{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
13667	–	{ (exit 1); exit 1; }; }
13668	–
13669	–	# Don't try to exec as it changes $[0], causing all sort of problems
13670	–	# (the dirname of $[0] is not the place where we might find the
13671	–	# original and so on. Autoconf is especially sensitive to this).
13672	–	. "./$as_me.lineno"
13673	–	# Exit status is that of the last command.
13674	–	exit
13675	–	}
13676	–
13677	–
13678	–	if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
13679	–	as_dirname=dirname
13680	–	else
13681	–	as_dirname=false
13682	–	fi
13683	–
11604		ECHO_C= ECHO_N= ECHO_T=
11605	<	case `echo -n x` in
11605	>	case `echo -n x` in #(((((
11606		-n*)
11607	<	case `echo 'x\c'` in
11607	>	case `echo 'xy\c'` in
11608		c) ECHO_T=' ';; # ECHO_T is single tab character.
11609	<	*) ECHO_C='\c';;
11609	>	xy) ECHO_C='\c';;
11610	>	*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
11611	>	ECHO_T=' ';;
11612		esac;;
11613		*)
11614		ECHO_N='-n';;
11615		esac
13694	–	if expr a : '$a$' >/dev/null 2>&1 &&
13695	–	test "X`expr 00001 : '.*$...$'`" = X001; then
13696	–	as_expr=expr
13697	–	else
13698	–	as_expr=false
13699	–	fi
11616
11617		rm -f conf$$ conf$$.exe conf$$.file
11618		if test -d conf$$.dir; then
#	Line 13724 \| Line 11640 \| rmdir conf$$.dir 2>/dev/null
11640		fi
11641		rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
11642		rmdir conf$$.dir 2>/dev/null
11643	+
11644	+
11645	+	# as_fn_mkdir_p
11646	+	# -------------
11647	+	# Create "$as_dir" as a directory, including parents if necessary.
11648	+	as_fn_mkdir_p ()
11649	+	{
11650	+
11651	+	case $as_dir in #(
11652	+	-*) as_dir=./$as_dir;;
11653	+	esac
11654	+	test -d "$as_dir" \|\| eval $as_mkdir_p \|\| {
11655	+	as_dirs=
11656	+	while :; do
11657	+	case $as_dir in #(
11658	+	\') as_qdir=`$as_echo "$as_dir" \| sed "s/'/'\\\\\\\\''/g"`;; #'(
11659	+	*) as_qdir=$as_dir;;
11660	+	esac
11661	+	as_dirs="'$as_qdir' $as_dirs"
11662	+	as_dir=`$as_dirname -- "$as_dir" \|\|
11663	+	$as_expr X"$as_dir" : 'X$.[^/]$//[^/][^/]/$' \\| \
11664	+	X"$as_dir" : 'X$//$[^/]' \\| \
11665	+	X"$as_dir" : 'X$//$$' \\| \
11666	+	X"$as_dir" : 'X$/$' \\| . 2>/dev/null \|\|
11667	+	$as_echo X"$as_dir" \|
11668	+	sed '/^X$.[^/]$\/\/[^/][^/]\/$/{
11669	+	s//\1/
11670	+	q
11671	+	}
11672	+	/^X$\/\/$[^/].*/{
11673	+	s//\1/
11674	+	q
11675	+	}
11676	+	/^X$\/\/$$/{
11677	+	s//\1/
11678	+	q
11679	+	}
11680	+	/^X$\/$.*/{
11681	+	s//\1/
11682	+	q
11683	+	}
11684	+	s/.*/./; q'`
11685	+	test -d "$as_dir" && break
11686	+	done
11687	+	test -z "$as_dirs" \|\| eval "mkdir $as_dirs"
11688	+	} \|\| test -d "$as_dir" \|\| as_fn_error "cannot create directory $as_dir"
11689
11690	+
11691	+	} # as_fn_mkdir_p
11692		if mkdir -p . 2>/dev/null; then
11693	<	as_mkdir_p=:
11693	>	as_mkdir_p='mkdir -p "$as_dir"'
11694		else
11695		test -d ./-p && rmdir ./-p
11696		as_mkdir_p=false
#	Line 13745 \| Line 11709 \| else
11709		if test -d "$1"; then
11710		test -d "$1/.";
11711		else
11712	<	case $1 in
11712	>	case $1 in #(
11713		-*)set "./$1";;
11714		esac;
11715	<	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
11715	>	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
11716		???[sx]):;;)false;;esac;fi
11717		'\'' sh
11718		'
#	Line 13763 \| Line 11727 \| exec 6>&1
11727
11728
11729		exec 6>&1
11730	+	## ----------------------------------- ##
11731	+	## Main body of $CONFIG_STATUS script. ##
11732	+	## ----------------------------------- ##
11733	+	_ASEOF
11734	+	test $as_write_fail = 0 && chmod +x $CONFIG_STATUS \|\| ac_write_fail=1
11735
11736	<	# Save the log message, to keep $[0] and so on meaningful, and to
11736	>	cat >>$CONFIG_STATUS <<\_ACEOF \|\| ac_write_fail=1
11737	>	# Save the log message, to keep $0 and so on meaningful, and to
11738		# report actual input values of CONFIG_FILES etc. instead of their
11739		# values after options handling.
11740		ac_log="
11741		This file was extended by OOPSE $as_me 4.0, which was
11742	<	generated by GNU Autoconf 2.62. Invocation command line was
11742	>	generated by GNU Autoconf 2.64. Invocation command line was
11743
11744		CONFIG_FILES = $CONFIG_FILES
11745		CONFIG_HEADERS = $CONFIG_HEADERS
#	Line 13782 \| Line 11752 \| _ACEOF
11752
11753		_ACEOF
11754
11755	+	case $ac_config_files in *"
11756	+	") set x $ac_config_files; shift; ac_config_files=$;;
11757	+	esac
11758	+
11759	+	case $ac_config_headers in *"
11760	+	") set x $ac_config_headers; shift; ac_config_headers=$;;
11761	+	esac
11762	+
11763	+
11764		cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
11765		# Files that config.status was made for.
11766		config_files="$ac_config_files"
#	Line 13791 \| Line 11770 \| ac_cs_usage="\
11770
11771		cat >>$CONFIG_STATUS <<\_ACEOF \|\| ac_write_fail=1
11772		ac_cs_usage="\
11773	<	\`$as_me' instantiates files from templates according to the
11774	<	current configuration.
11773	>	\`$as_me' instantiates files and other configuration actions
11774	>	from templates according to the current configuration. Unless the files
11775	>	and actions are specified as TAGs, all are instantiated by default.
11776
11777	<	Usage: $0 [OPTIONS] [FILE]...
11777	>	Usage: $0 [OPTION]... [TAG]...
11778
11779		-h, --help print this help, then exit
11780		-V, --version print version number and configuration settings, then exit
11781	<	-q, --quiet do not print progress messages
11781	>	-q, --quiet, --silent
11782	>	do not print progress messages
11783		-d, --debug don't remove temporary files
11784		--recheck update $as_me by reconfiguring in the same conditions
11785	<	--file=FILE[:TEMPLATE]
11785	>	--file=FILE[:TEMPLATE]
11786		instantiate the configuration file FILE
11787	<	--header=FILE[:TEMPLATE]
11787	>	--header=FILE[:TEMPLATE]
11788		instantiate the configuration header FILE
11789
11790		Configuration files:
#	Line 13812 \| Line 11793 \| $config_headers
11793		Configuration headers:
11794		$config_headers
11795
11796	<	Report bugs to <bug-autoconf@gnu.org>."
11796	>	Report bugs to <gezelter@nd.edu>."
11797
11798		_ACEOF
11799		cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
11800		ac_cs_version="\\
11801		OOPSE config.status 4.0
11802	<	configured by $0, generated by GNU Autoconf 2.62,
11802	>	configured by $0, generated by GNU Autoconf 2.64,
11803		with options \\"`$as_echo "$ac_configure_args" \| sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
11804
11805	<	Copyright (C) 2008 Free Software Foundation, Inc.
11805	>	Copyright (C) 2009 Free Software Foundation, Inc.
11806		This config.status script is free software; the Free Software Foundation
11807		gives unlimited permission to copy, distribute and modify it."
11808
#	Line 13862 \| Line 11843 \| do
11843		case $ac_optarg in
11844		\') ac_optarg=`$as_echo "$ac_optarg" \| sed "s/'/'\\\\\\\\''/g"` ;;
11845		esac
11846	<	CONFIG_FILES="$CONFIG_FILES '$ac_optarg'"
11846	>	as_fn_append CONFIG_FILES " '$ac_optarg'"
11847		ac_need_defaults=false;;
11848		--header \| --heade \| --head \| --hea )
11849		$ac_shift
11850		case $ac_optarg in
11851		\') ac_optarg=`$as_echo "$ac_optarg" \| sed "s/'/'\\\\\\\\''/g"` ;;
11852		esac
11853	<	CONFIG_HEADERS="$CONFIG_HEADERS '$ac_optarg'"
11853	>	as_fn_append CONFIG_HEADERS " '$ac_optarg'"
11854		ac_need_defaults=false;;
11855		--he \| --h)
11856		# Conflict between --help and --header
11857	<	{ $as_echo "$as_me: error: ambiguous option: $1
11858	<	Try \`$0 --help' for more information." >&2
13878	<	{ (exit 1); exit 1; }; };;
11857	>	as_fn_error "ambiguous option: \`$1'
11858	>	Try \`$0 --help' for more information.";;
11859		--help \| --hel \| -h )
11860		$as_echo "$ac_cs_usage"; exit ;;
11861		-q \| -quiet \| --quiet \| --quie \| --qui \| --qu \| --q \
#	Line 13883 \| Line 11863 \| Try \`$0 --help' for more information." >&2
11863		ac_cs_silent=: ;;
11864
11865		# This is an error.
11866	<	-*) { $as_echo "$as_me: error: unrecognized option: $1
11867	<	Try \`$0 --help' for more information." >&2
13888	<	{ (exit 1); exit 1; }; } ;;
11866	>	-*) as_fn_error "unrecognized option: \`$1'
11867	>	Try \`$0 --help' for more information." ;;
11868
11869	<	*) ac_config_targets="$ac_config_targets $1"
11869	>	*) as_fn_append ac_config_targets " $1"
11870		ac_need_defaults=false ;;
11871
11872		esac
#	Line 13941 \| Line 11920 \| do
11920		"src/applications/atom2md/Makefile") CONFIG_FILES="$CONFIG_FILES src/applications/atom2md/Makefile" ;;
11921		"scripts/filepp") CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
11922
11923	<	*) { { $as_echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13945	<	$as_echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13946	<	{ (exit 1); exit 1; }; };;
11923	>	*) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
11924		esac
11925		done
11926
#	Line 13969 \| Line 11946 \| $debug \|\|
11946		trap 'exit_status=$?
11947		{ test -z "$tmp" \|\| test ! -d "$tmp" \|\| rm -fr "$tmp"; } && exit $exit_status
11948		' 0
11949	<	trap '{ (exit 1); exit 1; }' 1 2 13 15
11949	>	trap 'as_fn_exit 1' 1 2 13 15
11950		}
11951		# Create a (secure) tmp directory for tmp files.
11952
#	Line 13980 \| Line 11957 \| $debug \|\|
11957		{
11958		tmp=./conf$$-$RANDOM
11959		(umask 077 && mkdir "$tmp")
11960	<	} \|\|
13984	<	{
13985	<	$as_echo "$as_me: cannot create a temporary directory in ." >&2
13986	<	{ (exit 1); exit 1; }
13987	<	}
11960	>	} \|\| as_fn_error "cannot create a temporary directory in ." "$LINENO" 5
11961
11962		# Set up the scripts for CONFIG_FILES section.
11963		# No need to generate them if there are no CONFIG_FILES.
#	Line 13992 \| Line 11965 \| if test -n "$CONFIG_FILES"; then
11965		if test -n "$CONFIG_FILES"; then
11966
11967
11968	<	ac_cr='
11969	<	'
11968	>	ac_cr=`echo X \| tr X '\015'`
11969	>	# On cygwin, bash can eat \r inside `` if the user requested igncr.
11970	>	# But we know of no other shell where ac_cr would be empty at this
11971	>	# point, so we can use a bashism as a fallback.
11972	>	if test "x$ac_cr" = x; then
11973	>	eval ac_cr=\$\'\\r\'
11974	>	fi
11975		ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
11976		if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
11977	<	ac_cs_awk_cr='\\r'
11977	>	ac_cs_awk_cr='\r'
11978		else
11979		ac_cs_awk_cr=$ac_cr
11980		fi
#	Line 14010 \| Line 11988 \| _ACEOF
11988		echo "$ac_subst_vars" \| sed 's/.*/&!$&$ac_delim/' &&
11989		echo "_ACEOF"
11990		} >conf$$subs.sh \|\|
11991	<	{ { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14014	<	$as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14015	<	{ (exit 1); exit 1; }; }
11991	>	as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
11992		ac_delim_num=`echo "$ac_subst_vars" \| grep -c '$'`
11993		ac_delim='%!_!# '
11994		for ac_last_try in false false false false false :; do
11995		. ./conf$$subs.sh \|\|
11996	<	{ { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14021	<	$as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14022	<	{ (exit 1); exit 1; }; }
11996	>	as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
11997
11998	<	if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk \| grep -c X` = $ac_delim_num; then
11998	>	ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk \| grep -c X`
11999	>	if test $ac_delim_n = $ac_delim_num; then
12000		break
12001		elif $ac_last_try; then
12002	<	{ { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14028	<	$as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14029	<	{ (exit 1); exit 1; }; }
12002	>	as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
12003		else
12004		ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
12005		fi
#	Line 14115 \| Line 12088 \| fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
12088		else
12089		cat
12090		fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
12091	<	\|\| { { $as_echo "$as_me:$LINENO: error: could not setup config files machinery" >&5
14119	<	$as_echo "$as_me: error: could not setup config files machinery" >&2;}
14120	<	{ (exit 1); exit 1; }; }
12091	>	\|\| as_fn_error "could not setup config files machinery" "$LINENO" 5
12092		_ACEOF
12093
12094		# VPATH may cause trouble with some makes, so we remove $(srcdir),
#	Line 14158 \| Line 12129 \| for ac_last_try in false false :; do
12129		if test -z "$ac_t"; then
12130		break
12131		elif $ac_last_try; then
12132	<	{ { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_HEADERS" >&5
14162	<	$as_echo "$as_me: error: could not make $CONFIG_HEADERS" >&2;}
14163	<	{ (exit 1); exit 1; }; }
12132	>	as_fn_error "could not make $CONFIG_HEADERS" "$LINENO" 5
12133		else
12134		ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
12135		fi
#	Line 14226 \| Line 12195 \| cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
12195		}
12196		split(mac1, mac2, "(") #)
12197		macro = mac2[1]
12198	+	prefix = substr(line, 1, index(line, defundef) - 1)
12199		if (D_is_set[macro]) {
12200		# Preserve the white space surrounding the "#".
14231	–	prefix = substr(line, 1, index(line, defundef) - 1)
12201		print prefix "define", macro P[macro] D[macro]
12202		next
12203		} else {
#	Line 14236 \| Line 12205 \| cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
12205		# in the case of _POSIX_SOURCE, which is predefined and required
12206		# on some systems where configure will not decide to define it.
12207		if (defundef == "undef") {
12208	<	print "/", line, "/"
12208	>	print "/", prefix defundef, macro, "/"
12209		next
12210		}
12211		}
#	Line 14245 \| Line 12214 \| cat >>$CONFIG_STATUS <<\_ACEOF \|\| ac_write_fail=1
12214		_ACAWK
12215		_ACEOF
12216		cat >>$CONFIG_STATUS <<\_ACEOF \|\| ac_write_fail=1
12217	<	{ { $as_echo "$as_me:$LINENO: error: could not setup config headers machinery" >&5
14249	<	$as_echo "$as_me: error: could not setup config headers machinery" >&2;}
14250	<	{ (exit 1); exit 1; }; }
12217	>	as_fn_error "could not setup config headers machinery" "$LINENO" 5
12218		fi # test -n "$CONFIG_HEADERS"
12219
12220
#	Line 14260 \| Line 12227 \| do
12227		esac
12228		case $ac_mode$ac_tag in
12229		:[FHL]:);;
12230	<	:L* \| :C:) { { $as_echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
14264	<	$as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
14265	<	{ (exit 1); exit 1; }; };;
12230	>	:L* \| :C:) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;;
12231		:[FH]-) ac_tag=-:-;;
12232		:[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
12233		esac
#	Line 14290 \| Line 12255 \| $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
12255		[\\/$]*) false;;
12256		*) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
12257		esac \|\|
12258	<	{ { $as_echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
14294	<	$as_echo "$as_me: error: cannot find input file: $ac_f" >&2;}
14295	<	{ (exit 1); exit 1; }; };;
12258	>	as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;;
12259		esac
12260		case $ac_f in \') ac_f=`$as_echo "$ac_f" \| sed "s/'/'\\\\\\\\''/g"`;; esac
12261	<	ac_file_inputs="$ac_file_inputs '$ac_f'"
12261	>	as_fn_append ac_file_inputs " '$ac_f'"
12262		done
12263
12264		# Let's still pretend it is `configure' which instantiates (i.e., don't
#	Line 14306 \| Line 12269 \| $as_echo "$as_me: error: cannot find input file: $ac_f
12269		`' by configure.'
12270		if test x"$ac_file" != x-; then
12271		configure_input="$ac_file. $configure_input"
12272	<	{ $as_echo "$as_me:$LINENO: creating $ac_file" >&5
12272	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
12273		$as_echo "$as_me: creating $ac_file" >&6;}
12274		fi
12275		# Neutralize special characters interpreted by sed in replacement strings.
#	Line 14319 \| Line 12282 \| $as_echo "$as_me: creating $ac_file" >&6;}
12282
12283		case $ac_tag in
12284		:-: \| *:-) cat >"$tmp/stdin" \
12285	<	\|\| { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14323	<	$as_echo "$as_me: error: could not create $ac_file" >&2;}
14324	<	{ (exit 1); exit 1; }; } ;;
12285	>	\|\| as_fn_error "could not create $ac_file" "$LINENO" 5 ;;
12286		esac
12287		;;
12288		esac
#	Line 14349 \| Line 12310 \| $as_echo X"$ac_file" \|
12310		q
12311		}
12312		s/.*/./; q'`
12313	<	{ as_dir="$ac_dir"
14353	<	case $as_dir in #(
14354	<	-*) as_dir=./$as_dir;;
14355	<	esac
14356	<	test -d "$as_dir" \|\| { $as_mkdir_p && mkdir -p "$as_dir"; } \|\| {
14357	<	as_dirs=
14358	<	while :; do
14359	<	case $as_dir in #(
14360	<	\') as_qdir=`$as_echo "$as_dir" \| sed "s/'/'\\\\\\\\''/g"`;; #'(
14361	<	*) as_qdir=$as_dir;;
14362	<	esac
14363	<	as_dirs="'$as_qdir' $as_dirs"
14364	<	as_dir=`$as_dirname -- "$as_dir" \|\|
14365	<	$as_expr X"$as_dir" : 'X$.[^/]$//[^/][^/]/$' \\| \
14366	<	X"$as_dir" : 'X$//$[^/]' \\| \
14367	<	X"$as_dir" : 'X$//$$' \\| \
14368	<	X"$as_dir" : 'X$/$' \\| . 2>/dev/null \|\|
14369	<	$as_echo X"$as_dir" \|
14370	<	sed '/^X$.[^/]$\/\/[^/][^/]\/$/{
14371	<	s//\1/
14372	<	q
14373	<	}
14374	<	/^X$\/\/$[^/].*/{
14375	<	s//\1/
14376	<	q
14377	<	}
14378	<	/^X$\/\/$$/{
14379	<	s//\1/
14380	<	q
14381	<	}
14382	<	/^X$\/$.*/{
14383	<	s//\1/
14384	<	q
14385	<	}
14386	<	s/.*/./; q'`
14387	<	test -d "$as_dir" && break
14388	<	done
14389	<	test -z "$as_dirs" \|\| eval "mkdir $as_dirs"
14390	<	} \|\| test -d "$as_dir" \|\| { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
14391	<	$as_echo "$as_me: error: cannot create directory $as_dir" >&2;}
14392	<	{ (exit 1); exit 1; }; }; }
12313	>	as_dir="$ac_dir"; as_fn_mkdir_p
12314		ac_builddir=.
12315
12316		case "$ac_dir" in
#	Line 14441 \| Line 12362 \| ac_datarootdir_hack=; ac_datarootdir_seen=
12362		# If the template does not know about datarootdir, expand it.
12363		# FIXME: This hack should be removed a few years after 2.60.
12364		ac_datarootdir_hack=; ac_datarootdir_seen=
14444	–
12365		ac_sed_dataroot='
12366		/datarootdir/ {
12367		p
#	Line 14451 \| Line 12371 \| ac_sed_dataroot='
12371		/@docdir@/p
12372		/@infodir@/p
12373		/@localedir@/p
12374	<	/@mandir@/p
14455	<	'
12374	>	/@mandir@/p'
12375		case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
12376		datarootdir) ac_datarootdir_seen=yes;;
12377		@datadir@\|@docdir@\|@infodir@\|@localedir@\|@mandir@)
12378	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
12378	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
12379		$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
12380		_ACEOF
12381		cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
#	Line 14466 \| Line 12385 \| cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
12385		s&@infodir@&$infodir&g
12386		s&@localedir@&$localedir&g
12387		s&@mandir@&$mandir&g
12388	<	s&\\\${datarootdir}&$datarootdir&g' ;;
12388	>	s&\\\${datarootdir}&$datarootdir&g' ;;
12389		esac
12390		_ACEOF
12391
#	Line 14494 \| Line 12413 \| eval sed \"\$ac_sed_extra\" "$ac_file_inputs" \| $AWK -
12413		$ac_datarootdir_hack
12414		"
12415		eval sed \"\$ac_sed_extra\" "$ac_file_inputs" \| $AWK -f "$tmp/subs.awk" >$tmp/out \
12416	<	\|\| { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14498	<	$as_echo "$as_me: error: could not create $ac_file" >&2;}
14499	<	{ (exit 1); exit 1; }; }
12416	>	\|\| as_fn_error "could not create $ac_file" "$LINENO" 5
12417
12418		test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
12419		{ ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
12420		{ ac_out=`sed -n '/^[ ]datarootdir[ ]:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
12421	<	{ $as_echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
12421	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
12422		which seems to be undefined. Please make sure it is defined." >&5
12423		$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
12424		which seems to be undefined. Please make sure it is defined." >&2;}
#	Line 14511 \| Line 12428 \| which seems to be undefined. Please make sure it is d
12428		-) cat "$tmp/out" && rm -f "$tmp/out";;
12429		*) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
12430		esac \
12431	<	\|\| { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14515	<	$as_echo "$as_me: error: could not create $ac_file" >&2;}
14516	<	{ (exit 1); exit 1; }; }
12431	>	\|\| as_fn_error "could not create $ac_file" "$LINENO" 5
12432		;;
12433		:H)
12434		#
#	Line 14524 \| Line 12439 \| $as_echo "$as_me: error: could not create $ac_file" >&
12439		$as_echo "/* $configure_input */" \
12440		&& eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs"
12441		} >"$tmp/config.h" \
12442	<	\|\| { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14528	<	$as_echo "$as_me: error: could not create $ac_file" >&2;}
14529	<	{ (exit 1); exit 1; }; }
12442	>	\|\| as_fn_error "could not create $ac_file" "$LINENO" 5
12443		if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then
12444	<	{ $as_echo "$as_me:$LINENO: $ac_file is unchanged" >&5
12444	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
12445		$as_echo "$as_me: $ac_file is unchanged" >&6;}
12446		else
12447		rm -f "$ac_file"
12448		mv "$tmp/config.h" "$ac_file" \
12449	<	\|\| { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14537	<	$as_echo "$as_me: error: could not create $ac_file" >&2;}
14538	<	{ (exit 1); exit 1; }; }
12449	>	\|\| as_fn_error "could not create $ac_file" "$LINENO" 5
12450		fi
12451		else
12452		$as_echo "/* $configure_input */" \
12453		&& eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \
12454	<	\|\| { { $as_echo "$as_me:$LINENO: error: could not create -" >&5
14544	<	$as_echo "$as_me: error: could not create -" >&2;}
14545	<	{ (exit 1); exit 1; }; }
12454	>	\|\| as_fn_error "could not create -" "$LINENO" 5
12455		fi
12456		;;
12457
#	Line 14562 \| Line 12471 \| done # for ac_tag
12471		done # for ac_tag
12472
12473
12474	<	{ (exit 0); exit 0; }
12474	>	as_fn_exit 0
12475		_ACEOF
14567	–	chmod +x $CONFIG_STATUS
12476		ac_clean_files=$ac_clean_files_save
12477
12478		test $ac_write_fail = 0 \|\|
12479	<	{ { $as_echo "$as_me:$LINENO: error: write failure creating $CONFIG_STATUS" >&5
14572	<	$as_echo "$as_me: error: write failure creating $CONFIG_STATUS" >&2;}
14573	<	{ (exit 1); exit 1; }; }
12479	>	as_fn_error "write failure creating $CONFIG_STATUS" "$LINENO" 5
12480
12481
12482		# configure is writing to config.log, and then calls config.status.
#	Line 14591 \| Line 12497 \| if test "$no_create" != yes; then
12497		exec 5>>config.log
12498		# Use \|\|, not &&, to avoid exiting from the if with $? = 1, which
12499		# would make configure fail if this is the last instruction.
12500	<	$ac_cs_success \|\| { (exit 1); exit 1; }
12500	>	$ac_cs_success \|\| as_fn_exit $?
12501		fi
12502		if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
12503	<	{ $as_echo "$as_me:$LINENO: WARNING: Unrecognized options: $ac_unrecognized_opts" >&5
12504	<	$as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2;}
12503	>	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
12504	>	$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
12505		fi
12506

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing trunk/configure (file contents): Revision 1311 by gezelter, Tue Oct 21 18:50:37 2008 UTC vs. Revision 1373 by gezelter, Tue Oct 20 13:13:45 2009 UTC

Diff Legend

Comparing trunk/configure (file contents):
Revision 1311 by gezelter, Tue Oct 21 18:50:37 2008 UTC vs.
Revision 1373 by gezelter, Tue Oct 20 13:13:45 2009 UTC