#! /bin/sh
# Generated from testsuite.at by GNU Autoconf 2.69.
#
# Copyright (C) 2009-2012 Free Software Foundation, Inc.
#
# This test suite is free software; the Free Software Foundation gives
# unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

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

if test "x$CONFIG_SHELL" = x; then
  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
  setopt NO_GLOB_SUBST
else
  case \`(set -o) 2>/dev/null\` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi
"
  as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }

exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :

else
  exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1
test -x / || exit 1"
  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
  if (eval "$as_required") 2>/dev/null; then :
  as_have_required=yes
else
  as_have_required=no
fi
  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :

else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  as_found=:
  case $as_dir in #(
	 /*)
	   for as_base in sh bash ksh sh5; do
	     # Try only shells that exist, to save several forks.
	     as_shell=$as_dir/$as_base
	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
  CONFIG_SHELL=$as_shell as_have_required=yes
		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
  break 2
fi
fi
	   done;;
       esac
  as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
  CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS


      if test "x$CONFIG_SHELL" != x; then :
  export CONFIG_SHELL
             # We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi

    if test x$as_have_required = xno; then :
  $as_echo "$0: This script requires a shell more modern than all"
  $as_echo "$0: the shells that I found on your system."
  if test x${ZSH_VERSION+set} = xset ; then
    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
  else
    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
$0: including any error possibly output before this
$0: message. Then install a modern shell, or manually run
$0: the script under such a shell if you do have one."
  fi
  exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS

## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset

# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p

# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error

if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits


  as_lineno_1=$LINENO as_lineno_1a=$LINENO
  as_lineno_2=$LINENO as_lineno_2a=$LINENO
  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      t loop
      s/-\n.*//
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }

  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
  # already done that, so ensure we don't try to do so again and fall
  # in an infinite loop.  This has already happened in practice.
  _as_can_reexec=no; export _as_can_reexec
  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensitive to this).
  . "./$as_me.lineno"
  # Exit status is that of the last command.
  exit
}

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"





SHELL=${CONFIG_SHELL-/bin/sh}

# How were we run?
at_cli_args="$@"


# Not all shells have the 'times' builtin; the subshell is needed to make
# sure we discard the 'times: not found' message from the shell.
at_times_p=false
(times) >/dev/null 2>&1 && at_times_p=:

# CLI Arguments to pass to the debugging scripts.
at_debug_args=
# -e sets to true
at_errexit_p=false
# Shall we be verbose?  ':' means no, empty means yes.
at_verbose=:
at_quiet=
# Running several jobs in parallel, 0 means as many as test groups.
at_jobs=1
at_traceon=:
at_trace_echo=:
at_check_filter_trace=:

# Shall we keep the debug scripts?  Must be `:' when the suite is
# run by a debug script, so that the script doesn't remove itself.
at_debug_p=false
# Display help message?
at_help_p=false
# Display the version message?
at_version_p=false
# List test groups?
at_list_p=false
# --clean
at_clean=false
# Test groups to run
at_groups=
# Whether to rerun failed tests.
at_recheck=
# Whether a write failure occurred
at_write_fail=0

# The directory we run the suite in.  Default to . if no -C option.
at_dir=`pwd`
# An absolute reference to this testsuite script.
case $as_myself in
  [\\/]* | ?:[\\/]* ) at_myself=$as_myself ;;
  * ) at_myself=$at_dir/$as_myself ;;
esac
# Whether -C is in effect.
at_change_dir=false

# Whether to enable colored test results.
at_color=no
# List of the tested programs.
at_tested=''
# As many question marks as there are digits in the last test group number.
# Used to normalize the test group numbers so that `ls' lists them in
# numerical order.
at_format='??'
# Description of all the test groups.
at_help_all="1;markup.at:17;markup;markup;
2;nopr.at:17;pr suppression;markup pr;
3;greek.at:17;Greek transliteration;greek transliteration xlit;
4;idx.at:17;idxgcide;idx idxgcide;
5;autoidx.at:17;Automatic indexing;idx autoidx;
6;descr.at:17;descr;descr;
7;info.at:17;info;info;
8;exact.at:17;exact;match exact;
9;prefix.at:17;prefix;match prefix;
10;all.at:17;all;match all;
11;def00.at:17;define (single entry);define def00;
12;def01.at:17;define (multiple entries);define def01;
13;def02.at:17;double-bar handling;define def02;
14;def04.at:17;mhw;define def04;
15;def05.at:17;mhw (second definition);define def05;
16;def06.at:17;first entry in page;define def06;
"
# List of the all the test groups.
at_groups_all=`$as_echo "$at_help_all" | sed 's/;.*//'`

# at_fn_validate_ranges NAME...
# -----------------------------
# Validate and normalize the test group number contained in each variable
# NAME. Leading zeroes are treated as decimal.
at_fn_validate_ranges ()
{
  for at_grp
  do
    eval at_value=\$$at_grp
    if test $at_value -lt 1 || test $at_value -gt 16; then
      $as_echo "invalid test group: $at_value" >&2
      exit 1
    fi
    case $at_value in
      0*) # We want to treat leading 0 as decimal, like expr and test, but
	  # AS_VAR_ARITH treats it as octal if it uses $(( )).
	  # With XSI shells, ${at_value#${at_value%%[1-9]*}} avoids the
	  # expr fork, but it is not worth the effort to determine if the
	  # shell supports XSI when the user can just avoid leading 0.
	  eval $at_grp='`expr $at_value + 0`' ;;
    esac
  done
}

at_prev=
for at_option
do
  # If the previous option needs an argument, assign it.
  if test -n "$at_prev"; then
    at_option=$at_prev=$at_option
    at_prev=
  fi

  case $at_option in
  *=?*) at_optarg=`expr "X$at_option" : '[^=]*=\(.*\)'` ;;
  *)    at_optarg= ;;
  esac

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

  case $at_option in
    --help | -h )
	at_help_p=:
	;;

    --list | -l )
	at_list_p=:
	;;

    --version | -V )
	at_version_p=:
	;;

    --clean | -c )
	at_clean=:
	;;

    --color )
	at_color=always
	;;
    --color=* )
	case $at_optarg in
	no | never | none) at_color=never ;;
	auto | tty | if-tty) at_color=auto ;;
	always | yes | force) at_color=always ;;
	*) at_optname=`echo " $at_option" | sed 's/^ //; s/=.*//'`
	   as_fn_error $? "unrecognized argument to $at_optname: $at_optarg" ;;
	esac
	;;

    --debug | -d )
	at_debug_p=:
	;;

    --errexit | -e )
	at_debug_p=:
	at_errexit_p=:
	;;

    --verbose | -v )
	at_verbose=; at_quiet=:
	;;

    --trace | -x )
	at_traceon='set -x'
	at_trace_echo=echo
	at_check_filter_trace=at_fn_filter_trace
	;;

    [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9])
	at_fn_validate_ranges at_option
	as_fn_append at_groups "$at_option$as_nl"
	;;

    # Ranges
    [0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-)
	at_range_start=`echo $at_option |tr -d X-`
	at_fn_validate_ranges at_range_start
	at_range=`$as_echo "$at_groups_all" | \
	  sed -ne '/^'$at_range_start'$/,$p'`
	as_fn_append at_groups "$at_range$as_nl"
	;;

    -[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9])
	at_range_end=`echo $at_option |tr -d X-`
	at_fn_validate_ranges at_range_end
	at_range=`$as_echo "$at_groups_all" | \
	  sed -ne '1,/^'$at_range_end'$/p'`
	as_fn_append at_groups "$at_range$as_nl"
	;;

    [0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9] | \
    [0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9] | \
    [0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] )
	at_range_start=`expr $at_option : '\(.*\)-'`
	at_range_end=`expr $at_option : '.*-\(.*\)'`
	if test $at_range_start -gt $at_range_end; then
	  at_tmp=$at_range_end
	  at_range_end=$at_range_start
	  at_range_start=$at_tmp
	fi
	at_fn_validate_ranges at_range_start at_range_end
	at_range=`$as_echo "$at_groups_all" | \
	  sed -ne '/^'$at_range_start'$/,/^'$at_range_end'$/p'`
	as_fn_append at_groups "$at_range$as_nl"
	;;

    # Directory selection.
    --directory | -C )
	at_prev=--directory
	;;
    --directory=* )
	at_change_dir=:
	at_dir=$at_optarg
	if test x- = "x$at_dir" ; then
	  at_dir=./-
	fi
	;;

    # Parallel execution.
    --jobs | -j )
	at_jobs=0
	;;
    --jobs=* | -j[0-9]* )
	if test -n "$at_optarg"; then
	  at_jobs=$at_optarg
	else
	  at_jobs=`expr X$at_option : 'X-j\(.*\)'`
	fi
	case $at_jobs in *[!0-9]*)
	  at_optname=`echo " $at_option" | sed 's/^ //; s/[0-9=].*//'`
	  as_fn_error $? "non-numeric argument to $at_optname: $at_jobs" ;;
	esac
	;;

    # Keywords.
    --keywords | -k )
	at_prev=--keywords
	;;
    --keywords=* )
	at_groups_selected=$at_help_all
	at_save_IFS=$IFS
	IFS=,
	set X $at_optarg
	shift
	IFS=$at_save_IFS
	for at_keyword
	do
	  at_invert=
	  case $at_keyword in
	  '!'*)
	    at_invert="-v"
	    at_keyword=`expr "X$at_keyword" : 'X!\(.*\)'`
	    ;;
	  esac
	  # It is on purpose that we match the test group titles too.
	  at_groups_selected=`$as_echo "$at_groups_selected" |
	      grep -i $at_invert "^[1-9][^;]*;.*[; ]$at_keyword[ ;]"`
	done
	# Smash the keywords.
	at_groups_selected=`$as_echo "$at_groups_selected" | sed 's/;.*//'`
	as_fn_append at_groups "$at_groups_selected$as_nl"
	;;
    --recheck)
	at_recheck=:
	;;

    *=*)
	at_envvar=`expr "x$at_option" : 'x\([^=]*\)='`
	# Reject names that are not valid shell variable names.
	case $at_envvar in
	  '' | [0-9]* | *[!_$as_cr_alnum]* )
	    as_fn_error $? "invalid variable name: \`$at_envvar'" ;;
	esac
	at_value=`$as_echo "$at_optarg" | sed "s/'/'\\\\\\\\''/g"`
	# Export now, but save eval for later and for debug scripts.
	export $at_envvar
	as_fn_append at_debug_args " $at_envvar='$at_value'"
	;;

     *) $as_echo "$as_me: invalid option: $at_option" >&2
	$as_echo "Try \`$0 --help' for more information." >&2
	exit 1
	;;
  esac
done

# Verify our last option didn't require an argument
if test -n "$at_prev"; then :
  as_fn_error $? "\`$at_prev' requires an argument"
fi

# The file containing the suite.
at_suite_log=$at_dir/$as_me.log

# Selected test groups.
if test -z "$at_groups$at_recheck"; then
  at_groups=$at_groups_all
else
  if test -n "$at_recheck" && test -r "$at_suite_log"; then
    at_oldfails=`sed -n '
      /^Failed tests:$/,/^Skipped tests:$/{
	s/^[ ]*\([1-9][0-9]*\):.*/\1/p
      }
      /^Unexpected passes:$/,/^## Detailed failed tests/{
	s/^[ ]*\([1-9][0-9]*\):.*/\1/p
      }
      /^## Detailed failed tests/q
      ' "$at_suite_log"`
    as_fn_append at_groups "$at_oldfails$as_nl"
  fi
  # Sort the tests, removing duplicates.
  at_groups=`$as_echo "$at_groups" | sort -nu | sed '/^$/d'`
fi

if test x"$at_color" = xalways \
   || { test x"$at_color" = xauto && test -t 1; }; then
  at_red=`printf '\033[0;31m'`
  at_grn=`printf '\033[0;32m'`
  at_lgn=`printf '\033[1;32m'`
  at_blu=`printf '\033[1;34m'`
  at_std=`printf '\033[m'`
else
  at_red= at_grn= at_lgn= at_blu= at_std=
fi

# Help message.
if $at_help_p; then
  cat <<_ATEOF || at_write_fail=1
Usage: $0 [OPTION]... [VARIABLE=VALUE]... [TESTS]

Run all the tests, or the selected TESTS, given by numeric ranges, and
save a detailed log file.  Upon failure, create debugging scripts.

Do not change environment variables directly.  Instead, set them via
command line arguments.  Set \`AUTOTEST_PATH' to select the executables
to exercise.  Each relative directory is expanded as build and source
directories relative to the top level of this distribution.
E.g., from within the build directory /tmp/foo-1.0, invoking this:

  $ $0 AUTOTEST_PATH=bin

is equivalent to the following, assuming the source directory is /src/foo-1.0:

  PATH=/tmp/foo-1.0/bin:/src/foo-1.0/bin:\$PATH $0
_ATEOF
cat <<_ATEOF || at_write_fail=1

Operation modes:
  -h, --help     print the help message, then exit
  -V, --version  print version number, then exit
  -c, --clean    remove all the files this test suite might create and exit
  -l, --list     describes all the tests, or the selected TESTS
_ATEOF
cat <<_ATEOF || at_write_fail=1

Execution tuning:
  -C, --directory=DIR
                 change to directory DIR before starting
      --color[=never|auto|always]
                 enable colored test results on terminal, or always
  -j, --jobs[=N]
                 Allow N jobs at once; infinite jobs with no arg (default 1)
  -k, --keywords=KEYWORDS
                 select the tests matching all the comma-separated KEYWORDS
                 multiple \`-k' accumulate; prefixed \`!' negates a KEYWORD
      --recheck  select all tests that failed or passed unexpectedly last time
  -e, --errexit  abort as soon as a test fails; implies --debug
  -v, --verbose  force more detailed output
                 default for debugging scripts
  -d, --debug    inhibit clean up and top-level logging
                 default for debugging scripts
  -x, --trace    enable tests shell tracing
_ATEOF
cat <<_ATEOF || at_write_fail=1

Report bugs to <bug-dico@gnu.org>.
General help using GNU software: <http://www.gnu.org/gethelp/>.
_ATEOF
  exit $at_write_fail
fi

# List of tests.
if $at_list_p; then
  cat <<_ATEOF || at_write_fail=1
GNU dico 2.4 test suite test groups:

 NUM: FILE-NAME:LINE     TEST-GROUP-NAME
      KEYWORDS

_ATEOF
  # Pass an empty line as separator between selected groups and help.
  $as_echo "$at_groups$as_nl$as_nl$at_help_all" |
    awk 'NF == 1 && FS != ";" {
	   selected[$ 1] = 1
	   next
	 }
	 /^$/ { FS = ";" }
	 NF > 0 {
	   if (selected[$ 1]) {
	     printf " %3d: %-18s %s\n", $ 1, $ 2, $ 3
	     if ($ 4) {
	       lmax = 79
	       indent = "     "
	       line = indent
	       len = length (line)
	       n = split ($ 4, a, " ")
	       for (i = 1; i <= n; i++) {
		 l = length (a[i]) + 1
		 if (i > 1 && len + l > lmax) {
		   print line
		   line = indent " " a[i]
		   len = length (line)
		 } else {
		   line = line " " a[i]
		   len += l
		 }
	       }
	       if (n)
		 print line
	     }
	   }
	 }' || at_write_fail=1
  exit $at_write_fail
fi
if $at_version_p; then
  $as_echo "$as_me (GNU dico 2.4)" &&
  cat <<\_ATEOF || at_write_fail=1

Copyright (C) 2012 Free Software Foundation, Inc.
This test suite is free software; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
_ATEOF
  exit $at_write_fail
fi

# Should we print banners?  Yes if more than one test is run.
case $at_groups in #(
  *$as_nl* )
      at_print_banners=: ;; #(
  * ) at_print_banners=false ;;
esac
# Text for banner N, set to a single space once printed.
# Banner 1. testsuite.at:30
# Category starts at test group 1.
at_banner_text_1="General"
# Banner 2. testsuite.at:37
# Category starts at test group 6.
at_banner_text_2="Dictionary info"
# Banner 3. testsuite.at:41
# Category starts at test group 8.
at_banner_text_3="Match"
# Banner 4. testsuite.at:46
# Category starts at test group 11.
at_banner_text_4="Define"

# Take any -C into account.
if $at_change_dir ; then
  test x != "x$at_dir" && cd "$at_dir" \
    || as_fn_error $? "unable to change directory"
  at_dir=`pwd`
fi

# Load the config files for any default variable assignments.
for at_file in atconfig atlocal
do
  test -r $at_file || continue
  . ./$at_file || as_fn_error $? "invalid content: $at_file"
done

# Autoconf <=2.59b set at_top_builddir instead of at_top_build_prefix:
: "${at_top_build_prefix=$at_top_builddir}"

# Perform any assignments requested during argument parsing.
eval "$at_debug_args"

# atconfig delivers names relative to the directory the test suite is
# in, but the groups themselves are run in testsuite-dir/group-dir.
if test -n "$at_top_srcdir"; then
  builddir=../..
  for at_dir_var in srcdir top_srcdir top_build_prefix
  do
    eval at_val=\$at_$at_dir_var
    case $at_val in
      [\\/$]* | ?:[\\/]* ) at_prefix= ;;
      *) at_prefix=../../ ;;
    esac
    eval "$at_dir_var=\$at_prefix\$at_val"
  done
fi

## -------------------- ##
## Directory structure. ##
## -------------------- ##

# This is the set of directories and files used by this script
# (non-literals are capitalized):
#
# TESTSUITE         - the testsuite
# TESTSUITE.log     - summarizes the complete testsuite run
# TESTSUITE.dir/    - created during a run, remains after -d or failed test
# + at-groups/      - during a run: status of all groups in run
# | + NNN/          - during a run: meta-data about test group NNN
# | | + check-line  - location (source file and line) of current AT_CHECK
# | | + status      - exit status of current AT_CHECK
# | | + stdout      - stdout of current AT_CHECK
# | | + stder1      - stderr, including trace
# | | + stderr      - stderr, with trace filtered out
# | | + test-source - portion of testsuite that defines group
# | | + times       - timestamps for computing duration
# | | + pass        - created if group passed
# | | + xpass       - created if group xpassed
# | | + fail        - created if group failed
# | | + xfail       - created if group xfailed
# | | + skip        - created if group skipped
# + at-stop         - during a run: end the run if this file exists
# + at-source-lines - during a run: cache of TESTSUITE line numbers for extraction
# + 0..NNN/         - created for each group NNN, remains after -d or failed test
# | + TESTSUITE.log - summarizes the group results
# | + ...           - files created during the group

# The directory the whole suite works in.
# Should be absolute to let the user `cd' at will.
at_suite_dir=$at_dir/$as_me.dir
# The file containing the suite ($at_dir might have changed since earlier).
at_suite_log=$at_dir/$as_me.log
# The directory containing helper files per test group.
at_helper_dir=$at_suite_dir/at-groups
# Stop file: if it exists, do not start new jobs.
at_stop_file=$at_suite_dir/at-stop
# The fifo used for the job dispatcher.
at_job_fifo=$at_suite_dir/at-job-fifo

if $at_clean; then
  test -d "$at_suite_dir" &&
    find "$at_suite_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
  rm -f -r "$at_suite_dir" "$at_suite_log"
  exit $?
fi

# Don't take risks: use only absolute directories in PATH.
#
# For stand-alone test suites (ie. atconfig was not found),
# AUTOTEST_PATH is relative to `.'.
#
# For embedded test suites, AUTOTEST_PATH is relative to the top level
# of the package.  Then expand it into build/src parts, since users
# may create executables in both places.
AUTOTEST_PATH=`$as_echo "$AUTOTEST_PATH" | sed "s|:|$PATH_SEPARATOR|g"`
at_path=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $AUTOTEST_PATH $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -n "$at_path" && as_fn_append at_path $PATH_SEPARATOR
case $as_dir in
  [\\/]* | ?:[\\/]* )
    as_fn_append at_path "$as_dir"
    ;;
  * )
    if test -z "$at_top_build_prefix"; then
      # Stand-alone test suite.
      as_fn_append at_path "$as_dir"
    else
      # Embedded test suite.
      as_fn_append at_path "$at_top_build_prefix$as_dir$PATH_SEPARATOR"
      as_fn_append at_path "$at_top_srcdir/$as_dir"
    fi
    ;;
esac
  done
IFS=$as_save_IFS


# Now build and simplify PATH.
#
# There might be directories that don't exist, but don't redirect
# builtins' (eg., cd) stderr directly: Ultrix's sh hates that.
at_new_path=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $at_path
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -d "$as_dir" || continue
case $as_dir in
  [\\/]* | ?:[\\/]* ) ;;
  * ) as_dir=`(cd "$as_dir" && pwd) 2>/dev/null` ;;
esac
case $PATH_SEPARATOR$at_new_path$PATH_SEPARATOR in
  *$PATH_SEPARATOR$as_dir$PATH_SEPARATOR*) ;;
  $PATH_SEPARATOR$PATH_SEPARATOR) at_new_path=$as_dir ;;
  *) as_fn_append at_new_path "$PATH_SEPARATOR$as_dir" ;;
esac
  done
IFS=$as_save_IFS

PATH=$at_new_path
export PATH

# Setting up the FDs.



# 5 is the log file.  Not to be overwritten if `-d'.
if $at_debug_p; then
  at_suite_log=/dev/null
else
  : >"$at_suite_log"
fi
exec 5>>"$at_suite_log"

# Banners and logs.
$as_echo "## ------------------------ ##
## GNU dico 2.4 test suite. ##
## ------------------------ ##"
{
  $as_echo "## ------------------------ ##
## GNU dico 2.4 test suite. ##
## ------------------------ ##"
  echo

  $as_echo "$as_me: command line was:"
  $as_echo "  \$ $0 $at_cli_args"
  echo

  # If ChangeLog exists, list a few lines in case it might help determining
  # the exact version.
  if test -n "$at_top_srcdir" && test -f "$at_top_srcdir/ChangeLog"; then
    $as_echo "## ---------- ##
## ChangeLog. ##
## ---------- ##"
    echo
    sed 's/^/| /;10q' "$at_top_srcdir/ChangeLog"
    echo
  fi

  {
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##

hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`

/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`

/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

_ASUNAME

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    $as_echo "PATH: $as_dir"
  done
IFS=$as_save_IFS

}
  echo

  # Contents of the config files.
  for at_file in atconfig atlocal
  do
    test -r $at_file || continue
    $as_echo "$as_me: $at_file:"
    sed 's/^/| /' $at_file
    echo
  done
} >&5


## ------------------------- ##
## Autotest shell functions. ##
## ------------------------- ##

# at_fn_banner NUMBER
# -------------------
# Output banner NUMBER, provided the testsuite is running multiple groups and
# this particular banner has not yet been printed.
at_fn_banner ()
{
  $at_print_banners || return 0
  eval at_banner_text=\$at_banner_text_$1
  test "x$at_banner_text" = "x " && return 0
  eval "at_banner_text_$1=\" \""
  if test -z "$at_banner_text"; then
    $at_first || echo
  else
    $as_echo "$as_nl$at_banner_text$as_nl"
  fi
} # at_fn_banner

# at_fn_check_prepare_notrace REASON LINE
# ---------------------------------------
# Perform AT_CHECK preparations for the command at LINE for an untraceable
# command; REASON is the reason for disabling tracing.
at_fn_check_prepare_notrace ()
{
  $at_trace_echo "Not enabling shell tracing (command contains $1)"
  $as_echo "$2" >"$at_check_line_file"
  at_check_trace=: at_check_filter=:
  : >"$at_stdout"; : >"$at_stderr"
}

# at_fn_check_prepare_trace LINE
# ------------------------------
# Perform AT_CHECK preparations for the command at LINE for a traceable
# command.
at_fn_check_prepare_trace ()
{
  $as_echo "$1" >"$at_check_line_file"
  at_check_trace=$at_traceon at_check_filter=$at_check_filter_trace
  : >"$at_stdout"; : >"$at_stderr"
}

# at_fn_check_prepare_dynamic COMMAND LINE
# ----------------------------------------
# Decide if COMMAND at LINE is traceable at runtime, and call the appropriate
# preparation function.
at_fn_check_prepare_dynamic ()
{
  case $1 in
    *$as_nl*)
      at_fn_check_prepare_notrace 'an embedded newline' "$2" ;;
    *)
      at_fn_check_prepare_trace "$2" ;;
  esac
}

# at_fn_filter_trace
# ------------------
# Remove the lines in the file "$at_stderr" generated by "set -x" and print
# them to stderr.
at_fn_filter_trace ()
{
  mv "$at_stderr" "$at_stder1"
  grep '^ *+' "$at_stder1" >&2
  grep -v '^ *+' "$at_stder1" >"$at_stderr"
}

# at_fn_log_failure FILE-LIST
# ---------------------------
# Copy the files in the list on stdout with a "> " prefix, and exit the shell
# with a failure exit code.
at_fn_log_failure ()
{
  for file
    do $as_echo "$file:"; sed 's/^/> /' "$file"; done
  echo 1 > "$at_status_file"
  exit 1
}

# at_fn_check_skip EXIT-CODE LINE
# -------------------------------
# Check whether EXIT-CODE is a special exit code (77 or 99), and if so exit
# the test group subshell with that same exit code. Use LINE in any report
# about test failure.
at_fn_check_skip ()
{
  case $1 in
    99) echo 99 > "$at_status_file"; at_failed=:
	$as_echo "$2: hard failure"; exit 99;;
    77) echo 77 > "$at_status_file"; exit 77;;
  esac
}

# at_fn_check_status EXPECTED EXIT-CODE LINE
# ------------------------------------------
# Check whether EXIT-CODE is the EXPECTED exit code, and if so do nothing.
# Otherwise, if it is 77 or 99, exit the test group subshell with that same
# exit code; if it is anything else print an error message referring to LINE,
# and fail the test.
at_fn_check_status ()
{
  case $2 in
    $1 ) ;;
    77) echo 77 > "$at_status_file"; exit 77;;
    99) echo 99 > "$at_status_file"; at_failed=:
	$as_echo "$3: hard failure"; exit 99;;
    *) $as_echo "$3: exit code was $2, expected $1"
      at_failed=:;;
  esac
}

# at_fn_diff_devnull FILE
# -----------------------
# Emit a diff between /dev/null and FILE. Uses "test -s" to avoid useless diff
# invocations.
at_fn_diff_devnull ()
{
  test -s "$1" || return 0
  $at_diff "$at_devnull" "$1"
}

# at_fn_test NUMBER
# -----------------
# Parse out test NUMBER from the tail of this file.
at_fn_test ()
{
  eval at_sed=\$at_sed$1
  sed "$at_sed" "$at_myself" > "$at_test_source"
}

# at_fn_create_debugging_script
# -----------------------------
# Create the debugging script $at_group_dir/run which will reproduce the
# current test group.
at_fn_create_debugging_script ()
{
  {
    echo "#! /bin/sh" &&
    echo 'test "${ZSH_VERSION+set}" = set && alias -g '\''${1+"$@"}'\''='\''"$@"'\''' &&
    $as_echo "cd '$at_dir'" &&
    $as_echo "exec \${CONFIG_SHELL-$SHELL} \"$at_myself\" -v -d $at_debug_args $at_group \${1+\"\$@\"}" &&
    echo 'exit 1'
  } >"$at_group_dir/run" &&
  chmod +x "$at_group_dir/run"
}

## -------------------------------- ##
## End of autotest shell functions. ##
## -------------------------------- ##
{
  $as_echo "## ---------------- ##
## Tested programs. ##
## ---------------- ##"
  echo
} >&5

# Report what programs are being tested.
for at_program in : $at_tested
do
  test "$at_program" = : && continue
  case $at_program in
    [\\/]* | ?:[\\/]* ) $at_program_=$at_program ;;
    * )
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -f "$as_dir/$at_program" && break
  done
IFS=$as_save_IFS

    at_program_=$as_dir/$at_program ;;
  esac
  if test -f "$at_program_"; then
    {
      $as_echo "$at_srcdir/testsuite.at:28: $at_program_ --version"
      "$at_program_" --version </dev/null
      echo
    } >&5 2>&1
  else
    as_fn_error $? "cannot find $at_program" "$LINENO" 5
  fi
done

{
  $as_echo "## ------------------ ##
## Running the tests. ##
## ------------------ ##"
} >&5

at_start_date=`date`
at_start_time=`date +%s 2>/dev/null`
$as_echo "$as_me: starting at: $at_start_date" >&5

# Create the master directory if it doesn't already exist.
as_dir="$at_suite_dir"; as_fn_mkdir_p ||
  as_fn_error $? "cannot create \`$at_suite_dir'" "$LINENO" 5

# Can we diff with `/dev/null'?  DU 5.0 refuses.
if diff /dev/null /dev/null >/dev/null 2>&1; then
  at_devnull=/dev/null
else
  at_devnull=$at_suite_dir/devnull
  >"$at_devnull"
fi

# Use `diff -u' when possible.
if at_diff=`diff -u "$at_devnull" "$at_devnull" 2>&1` && test -z "$at_diff"
then
  at_diff='diff -u'
else
  at_diff=diff
fi

# Get the last needed group.
for at_group in : $at_groups; do :; done

# Extract the start and end lines of each test group at the tail
# of this file
awk '
BEGIN { FS="" }
/^#AT_START_/ {
  start = NR
}
/^#AT_STOP_/ {
  test = substr ($ 0, 10)
  print "at_sed" test "=\"1," start "d;" (NR-1) "q\""
  if (test == "'"$at_group"'") exit
}' "$at_myself" > "$at_suite_dir/at-source-lines" &&
. "$at_suite_dir/at-source-lines" ||
  as_fn_error $? "cannot create test line number cache" "$LINENO" 5
rm -f "$at_suite_dir/at-source-lines"

# Set number of jobs for `-j'; avoid more jobs than test groups.
set X $at_groups; shift; at_max_jobs=$#
if test $at_max_jobs -eq 0; then
  at_jobs=1
fi
if test $at_jobs -ne 1 &&
   { test $at_jobs -eq 0 || test $at_jobs -gt $at_max_jobs; }; then
  at_jobs=$at_max_jobs
fi

# If parallel mode, don't output banners, don't split summary lines.
if test $at_jobs -ne 1; then
  at_print_banners=false
  at_quiet=:
fi

# Set up helper dirs.
rm -rf "$at_helper_dir" &&
mkdir "$at_helper_dir" &&
cd "$at_helper_dir" &&
{ test -z "$at_groups" || mkdir $at_groups; } ||
as_fn_error $? "testsuite directory setup failed" "$LINENO" 5

# Functions for running a test group.  We leave the actual
# test group execution outside of a shell function in order
# to avoid hitting zsh 4.x exit status bugs.

# at_fn_group_prepare
# -------------------
# Prepare for running a test group.
at_fn_group_prepare ()
{
  # The directory for additional per-group helper files.
  at_job_dir=$at_helper_dir/$at_group
  # The file containing the location of the last AT_CHECK.
  at_check_line_file=$at_job_dir/check-line
  # The file containing the exit status of the last command.
  at_status_file=$at_job_dir/status
  # The files containing the output of the tested commands.
  at_stdout=$at_job_dir/stdout
  at_stder1=$at_job_dir/stder1
  at_stderr=$at_job_dir/stderr
  # The file containing the code for a test group.
  at_test_source=$at_job_dir/test-source
  # The file containing dates.
  at_times_file=$at_job_dir/times

  # Be sure to come back to the top test directory.
  cd "$at_suite_dir"

  # Clearly separate the test groups when verbose.
  $at_first || $at_verbose echo

  at_group_normalized=$at_group

  eval 'while :; do
    case $at_group_normalized in #(
    '"$at_format"'*) break;;
    esac
    at_group_normalized=0$at_group_normalized
  done'


  # Create a fresh directory for the next test group, and enter.
  # If one already exists, the user may have invoked ./run from
  # within that directory; we remove the contents, but not the
  # directory itself, so that we aren't pulling the rug out from
  # under the shell's notion of the current directory.
  at_group_dir=$at_suite_dir/$at_group_normalized
  at_group_log=$at_group_dir/$as_me.log
  if test -d "$at_group_dir"; then
  find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx {} \;
  rm -fr "$at_group_dir"/* "$at_group_dir"/.[!.] "$at_group_dir"/.??*
fi ||
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: test directory for $at_group_normalized could not be cleaned" >&5
$as_echo "$as_me: WARNING: test directory for $at_group_normalized could not be cleaned" >&2;}
  # Be tolerant if the above `rm' was not able to remove the directory.
  as_dir="$at_group_dir"; as_fn_mkdir_p

  echo 0 > "$at_status_file"

  # In verbose mode, append to the log file *and* show on
  # the standard output; in quiet mode only write to the log.
  if test -z "$at_verbose"; then
    at_tee_pipe='tee -a "$at_group_log"'
  else
    at_tee_pipe='cat >> "$at_group_log"'
  fi
}

# at_fn_group_banner ORDINAL LINE DESC PAD [BANNER]
# -------------------------------------------------
# Declare the test group ORDINAL, located at LINE with group description DESC,
# and residing under BANNER. Use PAD to align the status column.
at_fn_group_banner ()
{
  at_setup_line="$2"
  test -n "$5" && at_fn_banner $5
  at_desc="$3"
  case $1 in
    [0-9])      at_desc_line="  $1: ";;
    [0-9][0-9]) at_desc_line=" $1: " ;;
    *)          at_desc_line="$1: "  ;;
  esac
  as_fn_append at_desc_line "$3$4"
  $at_quiet $as_echo_n "$at_desc_line"
  echo "#                             -*- compilation -*-" >> "$at_group_log"
}

# at_fn_group_postprocess
# -----------------------
# Perform cleanup after running a test group.
at_fn_group_postprocess ()
{
  # Be sure to come back to the suite directory, in particular
  # since below we might `rm' the group directory we are in currently.
  cd "$at_suite_dir"

  if test ! -f "$at_check_line_file"; then
    sed "s/^ */$as_me: WARNING: /" <<_ATEOF
      A failure happened in a test group before any test could be
      run. This means that test suite is improperly designed.  Please
      report this failure to <bug-dico@gnu.org>.
_ATEOF
    $as_echo "$at_setup_line" >"$at_check_line_file"
    at_status=99
  fi
  $at_verbose $as_echo_n "$at_group. $at_setup_line: "
  $as_echo_n "$at_group. $at_setup_line: " >> "$at_group_log"
  case $at_xfail:$at_status in
    yes:0)
	at_msg="UNEXPECTED PASS"
	at_res=xpass
	at_errexit=$at_errexit_p
	at_color=$at_red
	;;
    no:0)
	at_msg="ok"
	at_res=pass
	at_errexit=false
	at_color=$at_grn
	;;
    *:77)
	at_msg='skipped ('`cat "$at_check_line_file"`')'
	at_res=skip
	at_errexit=false
	at_color=$at_blu
	;;
    no:* | *:99)
	at_msg='FAILED ('`cat "$at_check_line_file"`')'
	at_res=fail
	at_errexit=$at_errexit_p
	at_color=$at_red
	;;
    yes:*)
	at_msg='expected failure ('`cat "$at_check_line_file"`')'
	at_res=xfail
	at_errexit=false
	at_color=$at_lgn
	;;
  esac
  echo "$at_res" > "$at_job_dir/$at_res"
  # In parallel mode, output the summary line only afterwards.
  if test $at_jobs -ne 1 && test -n "$at_verbose"; then
    $as_echo "$at_desc_line $at_color$at_msg$at_std"
  else
    # Make sure there is a separator even with long titles.
    $as_echo " $at_color$at_msg$at_std"
  fi
  at_log_msg="$at_group. $at_desc ($at_setup_line): $at_msg"
  case $at_status in
    0|77)
      # $at_times_file is only available if the group succeeded.
      # We're not including the group log, so the success message
      # is written in the global log separately.  But we also
      # write to the group log in case they're using -d.
      if test -f "$at_times_file"; then
	at_log_msg="$at_log_msg     ("`sed 1d "$at_times_file"`')'
	rm -f "$at_times_file"
      fi
      $as_echo "$at_log_msg" >> "$at_group_log"
      $as_echo "$at_log_msg" >&5

      # Cleanup the group directory, unless the user wants the files
      # or the success was unexpected.
      if $at_debug_p || test $at_res = xpass; then
	at_fn_create_debugging_script
	if test $at_res = xpass && $at_errexit; then
	  echo stop > "$at_stop_file"
	fi
      else
	if test -d "$at_group_dir"; then
	  find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
	  rm -fr "$at_group_dir"
	fi
	rm -f "$at_test_source"
      fi
      ;;
    *)
      # Upon failure, include the log into the testsuite's global
      # log.  The failure message is written in the group log.  It
      # is later included in the global log.
      $as_echo "$at_log_msg" >> "$at_group_log"

      # Upon failure, keep the group directory for autopsy, and create
      # the debugging script.  With -e, do not start any further tests.
      at_fn_create_debugging_script
      if $at_errexit; then
	echo stop > "$at_stop_file"
      fi
      ;;
  esac
}


## ------------ ##
## Driver loop. ##
## ------------ ##


if (set -m && set +m && set +b) >/dev/null 2>&1; then
  set +b
  at_job_control_on='set -m' at_job_control_off='set +m' at_job_group=-
else
  at_job_control_on=: at_job_control_off=: at_job_group=
fi

for at_signal in 1 2 15; do
  trap 'set +x; set +e
	$at_job_control_off
	at_signal='"$at_signal"'
	echo stop > "$at_stop_file"
	trap "" $at_signal
	at_pgids=
	for at_pgid in `jobs -p 2>/dev/null`; do
	  at_pgids="$at_pgids $at_job_group$at_pgid"
	done
	test -z "$at_pgids" || kill -$at_signal $at_pgids 2>/dev/null
	wait
	if test "$at_jobs" -eq 1 || test -z "$at_verbose"; then
	  echo >&2
	fi
	at_signame=`kill -l $at_signal 2>&1 || echo $at_signal`
	set x $at_signame
	test 0 -gt 2 && at_signame=$at_signal
	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: caught signal $at_signame, bailing out" >&5
$as_echo "$as_me: WARNING: caught signal $at_signame, bailing out" >&2;}
	as_fn_arith 128 + $at_signal && exit_status=$as_val
	as_fn_exit $exit_status' $at_signal
done

rm -f "$at_stop_file"
at_first=:

if test $at_jobs -ne 1 &&
     rm -f "$at_job_fifo" &&
     test -n "$at_job_group" &&
     ( mkfifo "$at_job_fifo" && trap 'exit 1' PIPE STOP TSTP ) 2>/dev/null
then
  # FIFO job dispatcher.

  trap 'at_pids=
	for at_pid in `jobs -p`; do
	  at_pids="$at_pids $at_job_group$at_pid"
	done
	if test -n "$at_pids"; then
	  at_sig=TSTP
	  test "${TMOUT+set}" = set && at_sig=STOP
	  kill -$at_sig $at_pids 2>/dev/null
	fi
	kill -STOP $$
	test -z "$at_pids" || kill -CONT $at_pids 2>/dev/null' TSTP

  echo
  # Turn jobs into a list of numbers, starting from 1.
  at_joblist=`$as_echo "$at_groups" | sed -n 1,${at_jobs}p`

  set X $at_joblist
  shift
  for at_group in $at_groups; do
    $at_job_control_on 2>/dev/null
    (
      # Start one test group.
      $at_job_control_off
      if $at_first; then
	exec 7>"$at_job_fifo"
      else
	exec 6<&-
      fi
      trap 'set +x; set +e
	    trap "" PIPE
	    echo stop > "$at_stop_file"
	    echo >&7
	    as_fn_exit 141' PIPE
      at_fn_group_prepare
      if cd "$at_group_dir" &&
	 at_fn_test $at_group &&
	 . "$at_test_source"
      then :; else
	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5
$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;}
	at_failed=:
      fi
      at_fn_group_postprocess
      echo >&7
    ) &
    $at_job_control_off
    if $at_first; then
      at_first=false
      exec 6<"$at_job_fifo" 7>"$at_job_fifo"
    fi
    shift # Consume one token.
    if test $# -gt 0; then :; else
      read at_token <&6 || break
      set x $*
    fi
    test -f "$at_stop_file" && break
  done
  exec 7>&-
  # Read back the remaining ($at_jobs - 1) tokens.
  set X $at_joblist
  shift
  if test $# -gt 0; then
    shift
    for at_job
    do
      read at_token
    done <&6
  fi
  exec 6<&-
  wait
else
  # Run serially, avoid forks and other potential surprises.
  for at_group in $at_groups; do
    at_fn_group_prepare
    if cd "$at_group_dir" &&
       at_fn_test $at_group &&
       . "$at_test_source"; then :; else
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5
$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;}
      at_failed=:
    fi
    at_fn_group_postprocess
    test -f "$at_stop_file" && break
    at_first=false
  done
fi

# Wrap up the test suite with summary statistics.
cd "$at_helper_dir"

# Use ?..???? when the list must remain sorted, the faster * otherwise.
at_pass_list=`for f in */pass; do echo $f; done | sed '/\*/d; s,/pass,,'`
at_skip_list=`for f in */skip; do echo $f; done | sed '/\*/d; s,/skip,,'`
at_xfail_list=`for f in */xfail; do echo $f; done | sed '/\*/d; s,/xfail,,'`
at_xpass_list=`for f in ?/xpass ??/xpass ???/xpass ????/xpass; do
		 echo $f; done | sed '/?/d; s,/xpass,,'`
at_fail_list=`for f in ?/fail ??/fail ???/fail ????/fail; do
		echo $f; done | sed '/?/d; s,/fail,,'`

set X $at_pass_list $at_xpass_list $at_xfail_list $at_fail_list $at_skip_list
shift; at_group_count=$#
set X $at_xpass_list; shift; at_xpass_count=$#; at_xpass_list=$*
set X $at_xfail_list; shift; at_xfail_count=$#
set X $at_fail_list; shift; at_fail_count=$#; at_fail_list=$*
set X $at_skip_list; shift; at_skip_count=$#

as_fn_arith $at_group_count - $at_skip_count && at_run_count=$as_val
as_fn_arith $at_xpass_count + $at_fail_count && at_unexpected_count=$as_val
as_fn_arith $at_xfail_count + $at_fail_count && at_total_fail_count=$as_val

# Back to the top directory.
cd "$at_dir"
rm -rf "$at_helper_dir"

# Compute the duration of the suite.
at_stop_date=`date`
at_stop_time=`date +%s 2>/dev/null`
$as_echo "$as_me: ending at: $at_stop_date" >&5
case $at_start_time,$at_stop_time in
  [0-9]*,[0-9]*)
    as_fn_arith $at_stop_time - $at_start_time && at_duration_s=$as_val
    as_fn_arith $at_duration_s / 60 && at_duration_m=$as_val
    as_fn_arith $at_duration_m / 60 && at_duration_h=$as_val
    as_fn_arith $at_duration_s % 60 && at_duration_s=$as_val
    as_fn_arith $at_duration_m % 60 && at_duration_m=$as_val
    at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s"
    $as_echo "$as_me: test suite duration: $at_duration" >&5
    ;;
esac

echo
$as_echo "## ------------- ##
## Test results. ##
## ------------- ##"
echo
{
  echo
  $as_echo "## ------------- ##
## Test results. ##
## ------------- ##"
  echo
} >&5

if test $at_run_count = 1; then
  at_result="1 test"
  at_were=was
else
  at_result="$at_run_count tests"
  at_were=were
fi
if $at_errexit_p && test $at_unexpected_count != 0; then
  if test $at_xpass_count = 1; then
    at_result="$at_result $at_were run, one passed"
  else
    at_result="$at_result $at_were run, one failed"
  fi
  at_result="$at_result unexpectedly and inhibited subsequent tests."
  at_color=$at_red
else
  # Don't you just love exponential explosion of the number of cases?
  at_color=$at_red
  case $at_xpass_count:$at_fail_count:$at_xfail_count in
    # So far, so good.
    0:0:0) at_result="$at_result $at_were successful." at_color=$at_grn ;;
    0:0:*) at_result="$at_result behaved as expected." at_color=$at_lgn ;;

    # Some unexpected failures
    0:*:0) at_result="$at_result $at_were run,
$at_fail_count failed unexpectedly." ;;

    # Some failures, both expected and unexpected
    0:*:1) at_result="$at_result $at_were run,
$at_total_fail_count failed ($at_xfail_count expected failure)." ;;
    0:*:*) at_result="$at_result $at_were run,
$at_total_fail_count failed ($at_xfail_count expected failures)." ;;

    # No unexpected failures, but some xpasses
    *:0:*) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly." ;;

    # No expected failures, but failures and xpasses
    *:1:0) at_result="$at_result $at_were run,
$at_unexpected_count did not behave as expected ($at_fail_count unexpected failure)." ;;
    *:*:0) at_result="$at_result $at_were run,
$at_unexpected_count did not behave as expected ($at_fail_count unexpected failures)." ;;

    # All of them.
    *:*:1) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly,
$at_total_fail_count failed ($at_xfail_count expected failure)." ;;
    *:*:*) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly,
$at_total_fail_count failed ($at_xfail_count expected failures)." ;;
  esac

  if test $at_skip_count = 0 && test $at_run_count -gt 1; then
    at_result="All $at_result"
  fi
fi

# Now put skips in the mix.
case $at_skip_count in
  0) ;;
  1) at_result="$at_result
1 test was skipped." ;;
  *) at_result="$at_result
$at_skip_count tests were skipped." ;;
esac

if test $at_unexpected_count = 0; then
  echo "$at_color$at_result$at_std"
  echo "$at_result" >&5
else
  echo "${at_color}ERROR: $at_result$at_std" >&2
  echo "ERROR: $at_result" >&5
  {
    echo
    $as_echo "## ------------------------ ##
## Summary of the failures. ##
## ------------------------ ##"

    # Summary of failed and skipped tests.
    if test $at_fail_count != 0; then
      echo "Failed tests:"
      $SHELL "$at_myself" $at_fail_list --list
      echo
    fi
    if test $at_skip_count != 0; then
      echo "Skipped tests:"
      $SHELL "$at_myself" $at_skip_list --list
      echo
    fi
    if test $at_xpass_count != 0; then
      echo "Unexpected passes:"
      $SHELL "$at_myself" $at_xpass_list --list
      echo
    fi
    if test $at_fail_count != 0; then
      $as_echo "## ---------------------- ##
## Detailed failed tests. ##
## ---------------------- ##"
      echo
      for at_group in $at_fail_list
      do
	at_group_normalized=$at_group

  eval 'while :; do
    case $at_group_normalized in #(
    '"$at_format"'*) break;;
    esac
    at_group_normalized=0$at_group_normalized
  done'

	cat "$at_suite_dir/$at_group_normalized/$as_me.log"
	echo
      done
      echo
    fi
    if test -n "$at_top_srcdir"; then
      sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## ${at_top_build_prefix}config.log ##
_ASBOX
      sed 's/^/| /' ${at_top_build_prefix}config.log
      echo
    fi
  } >&5

  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $as_me.log was created. ##
_ASBOX

  echo
  if $at_debug_p; then
    at_msg='per-test log files'
  else
    at_msg="\`${at_testdir+${at_testdir}/}$as_me.log'"
  fi
  $as_echo "Please send $at_msg and all information you think might help:

   To: <bug-dico@gnu.org>
   Subject: [GNU dico 2.4] $as_me: $at_fail_list${at_fail_list:+ failed${at_xpass_list:+, }}$at_xpass_list${at_xpass_list:+ passed unexpectedly}

You may investigate any problem if you feel able to do so, in which
case the test suite provides a good starting point.  Its output may
be found below \`${at_testdir+${at_testdir}/}$as_me.dir'.
"
  exit 1
fi

exit 0

## ------------- ##
## Actual tests. ##
## ------------- ##
#AT_START_1
at_fn_group_banner 1 'markup.at:17' \
  "markup" "                                         " 1
at_xfail=no
(
  $as_echo "1. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >input <<'_ATEOF'
<p><hw>Ac`ro*te"ri*al</hw> <pr>(<acr/k`r<osl/*t<emac/"r<icr/*<ait/l)</pr>, <pos>a.</pos> <def>Pertaining to an acroterium; <as>as, <ex>acroterial</ex> ornaments</as>.</def>  <rj><au>P. Cyc.</au></rj><br/
[<source>1913 Webster</source>]</p>
_ATEOF


{ set +x
$as_echo "$at_srcdir/markup.at:24: degcide input"
at_fn_check_prepare_trace "markup.at:24"
( $at_check_trace; degcide input
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Acroterial (ăkrotērĭal), a. Pertaining to an acroterium; as, \`\`acroterial ornaments''.  P. Cyc.

[1913 Webster]
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/markup.at:24"
$at_failed && at_fn_log_failure
$at_traceon; }


  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_1
#AT_START_2
at_fn_group_banner 2 'nopr.at:17' \
  "pr suppression" "                                 " 1
at_xfail=no
(
  $as_echo "2. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
<p><hw>Ac`ro*te"ri*al</hw> <pr>(<acr/k`r<osl/*t<emac/"r<icr/*<ait/l)</pr>, <pos>a.</pos> <def>Pertaining to an acroterium; <as>as, <ex>acroterial</ex> ornaments</as>.</def>  <rj><au>P. Cyc.</au></rj><br/
[<source>1913 Webster</source>]</p>
_ATEOF


{ set +x
$as_echo "$at_srcdir/nopr.at:25: degcide -nopr input"
at_fn_check_prepare_trace "nopr.at:25"
( $at_check_trace; degcide -nopr input
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Acroterial , a. Pertaining to an acroterium; as, \`\`acroterial ornaments''.  P. Cyc.

[1913 Webster]
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/nopr.at:25"
$at_failed && at_fn_log_failure
$at_traceon; }


  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_2
#AT_START_3
at_fn_group_banner 3 'greek.at:17' \
  "Greek transliteration" "                          " 1
at_xfail=no
(
  $as_echo "3. $at_setup_line: testing $at_desc ..."
  $at_traceon


# These string has been extracted from the GCIDE files with exgrk:
cat >input <<'_ATEOF'
'a
'a-
a,
'abaki`skos
'a`bax
'abba^s
'Abdhri`ths
'acha`ths
'a`chnh
'a`chos
'ada`mas
'adelfo`s
'adhfa`gos
"a`,dhs
'a`dnh
-a`dos
"adro`s
'A`dwnis
'aei`dein
'a`flaston
'a`fws
'a`fwtos
'agalakti`a
a`ga`llochon
'a`galma
'a`galmatos
'a`gamos
'aga`pai
'aga`ph
'a`gchein
'a`gein
a`gelos
'a`ggaros
'aggei^on
'a`ggelein
'a`ggelos
'aggoy`rion
'agh`raton
"agio`grafa
"agio`grafos
"a`gios
'a`gkos
'agkw`n
'agky`los
'a`gkyra
'a`gnoia
'agny`nai
'agonisth`s
'agora`
'a`grios
'agwgo`s
'agw`n
'a`gyris
'ah^nai
'ah`r
'ah`ths
ai
"A'idhs
a"i ko`loyroi
'ai^ma
a'i^ma
a"i^ma
a"imatiko`s
a"i`matos
a"ima`twsis
a"imorragi`a
a"imorragiko`s
a'i`nigma
a'ini`ssesqai
a'i^nos
A'ioliko`s
A'ioli`s
a'i`qein
a'iqh`r
a'i^qos
a'i`rein
a'iwn
'a`kanqa
'ake`falos
'akei^sqai
'akh`
'akinhtos
'a`kmwn
'akoy`ein
akrasia
'akroli`qos
'a`kron
'akro`nychos
'akro`nyktos
'akro`polis
'a`kros
'akro`tomos
'akrwth`rion
'ala`bastros
'alao`s
'ale`gein
'a`lfa
'a`lghsis
'a`lgos
"alieytiko`s
'alkh`
'a`lkimos
'alkyo`nion
'alkyw`n
"alkyw`n
"a`llesqai
'allo`trios
"a`lma
'alo`h
"alo`s
-a`loy
"a`ls
"alth^res
"a`lwn
"a`lwnos
'alwpeki`a
'alw`phx
"a`lws
"a`lysis
'a`lysson
"a`ma
"Amadrya`s
"amamhli`s
'ama^n
'ama`rakon
'ama`rakos
'a`mbix
'a`mbrotos
'amei`bein
'ame`lgein
'a`menai
'ame`rgein
'amfi`
'amfiba`llein
'amfi`bios
'amfiboli`a
'amfi`bolos
'amfi`dromos
'a`mfw
'amh`n
'ammi`ths
'ammi`tis
"ammo`chrysos
'a`mmos
"a`mmos
'amnhsi`a
'amo`rghs
'ampeli^tis
'a`mpelos
'amygda`lh
'a`myos
'an
'ana`
'anabaptismo`s
'anabaptisth`s
'anafe`rein
'anafora`
'anagra`fein
'anagrafh`
'anagrammatismo`s
'anagrammati`zein
'anaimi`a
'analamba`nein
'anale`gein
'ana`lekta
'analghsi`a
'ana`lhmma
'analkh`s
'ana`mnhsis
'a`narqros
'anastaltiko`s
'andh`r
'androeidh`s
'androfa`gos
'andro`s
andro`s
'andrw`n
'a`nemos
'a`nhqon
'anh`r
anh`r
'a`nison
'a`nisos
'a`noplos
-anos
'anqei^n
'anqemi`s
'anqolo`gos
'anqo`lops
'a`nqos
'anqrh`nh
'anqropofyh`s
'a`nqropos
'a`nqrwpos
'anti`
'anti`doton
'anti`dotos
'anti`fwna
'anti`fwnon
'anti`fwnos
'antilogi`a
'anti`logos
'a`ntoiki
-antos
'a`nw
'anwfelh`s
'aoidh`
'aoristiko`s
'ao`ristos
"aplo`os
apo
'apo`
'apofa`nai
'apo`fasis
'apofey`gein
'apofqe`ggesqai
'apo`fqegma
'apofqegmatiko`s
'apofygh`
'apope`mpein
'apopemptiko`s
'apoplh`ssein
'apoplhxi`a
"apsi^dos
"apsi`s
"a`ptein
'apwte`rw
'aqanasi`a
'aqa`natos
'Aqhna^
'Aqhna`a
'Aqhnai`a
'Aqhnai`n
'Aqhnai`on
'Aqh`nh
'araia`
'araio`s
'arch-
'archa`ggelos
'archai:ko`s
'archaiologi`a
'archai^os
'archai:smo`s
'archai:`zein
'arche
'a`rchein
'arche`typon
'arche`typos
'archh
'archh`
'archi
'archi-
'archiepi`skopos
'archiko`s
'archo`s
'a`rchwn
'argh`s
'argo`s
'a`rgyros
'ariqmo`s
'arkei^n
"armoni`a
"armoniko`s
"armo`s
"armosth`s
"armo`zein
"arpa`gh
'arpa`zein
"arpa`zein
"a`rph
"a`rpyia
'arqritiko`s
'arqri`tis
'arqri^tis
'a`rqron
'arrabw`n
'arreniko`n
'arreniko`s
'a`rrhn
'arseniko`n
'arseniko`s
'a`rsis
'A`rtemis
'Artemisi`a
'arthri`a
'a^sai
'a`saron
'asfa`ragos
'asfo`delos
'askhqh`s
'asko`s
'aspa`ragos
'aspi`s
'a`spron
'a`spros
'asqe`nia
'asqeniko`s
'asteri`as
'aste`rion
'asth`r
'astrola`bon
'astrologi`a
'astrologiko`s
'astrolo`gos
'a`stron
'astronomiko`s
'ataraxi`a
-atos
'axi`nh
'a`xwn
a"y`ein
a'ygh`
a'ygi`ths
a'ytoptiko`s
a'yto`s
'a`yws
bai`nein
bai`tylos
Bakchiko`s
Ba`kchos
bakth`rion
ba`ktron
bala`ni
balania`
balani`di
balanidia`
ba`lanos
balay`stion
balei^n
baliarei^s
ba`llein
balli`zein
balsami`nh
ba`lsamon
bambai`nein
bambali`zein
ba`ptein
ba`ptisma
baptisth`rion
baptisth`s
baptistiko`s
bapti`zein
ba`qos
baqo`s
baqy`s
barbariko`s
barbarismo`s
ba`rbaros
ba`rbiton
ba`ros
bary`s
bary`ths
bary`tonos
ba`sanos
basilei^ai
basiley`s
basilikh`
basiliko`n
basiliko`s
basili`skos
ba`sis
basta`zein
ba`ths
ba`tos
batra`cheios
batrachomyomachi`a
ba`trachos
battologi`a
ba`ttos
bde`lla
bde`llion
be`nqos
Bereni`kh
Beroni`kh
bh`ryllos
bh^ta
bibli`a
bibliografi`a
bibli`on
bi`blion gewrgiko`n
bi`blos
bibrw`skein
bi^kos
bi`os
bioy^n
bi`swn
biw^n
bi`wsis
biwtiko`s
blapsi`fhmos
bla`psis
bla`ptein
blasfhmei^n
bla`sfhmos
blasta`nein
bla`sthma
blastiko`s
blasto`s
ble`psis
bli`ton
bo`ax
bolbo`s
bombylio`s
boo`s
Bo`sporos
boubw`n
bow`ths
boy`kerws
boylimi`a
boy`s
boy^s
boy`turon
bra`chistos
brachy`s
bra`gchion
bre`chein
brechmo`s
bre`gma
bro`chqos
bronth`
broto`s
brw^ma
bry`ein
bry^ton
brywni`a
bw^x
by`blos
by`rsa
by`ssinos
by`ssos
cha
chabazi`os
cha`inein
chai`nein
chai`rein
chai`th
cha`lkanqos
CHalkhdw`n
chalki`s
chalko`s
chamai`
chamaile`wn
chamai`mhlon
chanda`nein
cha`os
cha`ris
cha`rybdis
cha`sma
cheia`
chei^n
chei`r
cheiro`s
chelido`nios
chelidw`n
chelw`nh
cherso`nhsos
che`rsos
chhlh`
chh`n
chh`r
chi`asma
chiasmo`s
chiasto`s
chia`zein
chiliado`s
chilia`s
chi`lioi
chlamy`dos
chlamy`s
chlo`n
chlwro`s
choa`nh
chola`des
cho`ndros
chordh`
cho`rion
cho`rtos
chorto`s
chri`ein
chri^sma
Christo`s
CHRISTOS
chro`a
chroa`
CHro`nos
chrw^ma
chrw`s
chryso`kolla
chryso`s
chw`ra
chw^ros
chylopoiei^n
chylo`s
da`fnh
Dagw`n
dah`r
daimoniko`s
dai`mwn
da`knein
da`kry
da`kryma
da`kryon
daktyliko`s
daktyliogly`fos
dakty`lios
da`ktylos
dama^,n
Damasko`s
da^mos
dareiko`s
dasy`s
de`hsis
deikny`nai
deiktiko`s
dei^ma
dei^n
deino`s
dei^pnon
deipnosofisth`s
de`ka
deka`chordos
de`katos
Delfiko`s
delfi`n
delfi`s
Delfoi`
delfy`s
de`lta
deltoeidh`s
dendri`ths
dendri^tis
de`ndron
de`rein
de`rkesqai
de`rma
dermhsth`s
de`ros
de`smh
desmo`s
despo`ths
despotiko`s
dey`teron
dey`teros
dhlei^sqai
dhlhth`rios
dhmagwgi`a
dhmagwgo`s
dhmagwkiko`s
dh`marchos
dh`mios
dhmioyrgiko`s
dhmioyrgo`s
dhmokrati`a
dh^mos
dhmotiko`s
dhna`rion
di
di-
dia`
diakla^n
dia`konos
diapasw^n
dia`pente
dia`rrei^n
dia`rroia
diate`mnein
dia`tomos
di`daxis
dido`nai
di`dymos
difyh`s
dikasth`rion
dikasth`s
dika`zein
dike`falos
dikei^n
di`kh
di`ktamnon
di`ktamnos
di^os
Dio`s
di-pla`sios
diplo`os
dis
di`s
di`s-
di`skos
dissologi`a
dittologi`a
do`gma
do`gmata
dogmatiko`s
dokei^n
dolero`s
dolicho`s
do`mos
do`ry
do`sis
do`xa
doy^los
drachmh`
dra`kein
dra`kwn
dra^ma
dramatiko`s
dramei^n
dra^n
dra`ssesqai
drimy`s
droma`s
dro`mos
dro`mwn
drosero`s
dro`sos
dry`ppa
dry^s
dw^ron
dy`ein
dynastei`a
dynastey`ein
dyna`sths
dy`o
dys-
dyskrasi`a
dyspro`sitos
'e`
'e`ar
"ebdoma`s
'e`chein
'e`chidna
'echi^nos
'e`chis
'e`dein
'e`dra
"e`dra
"edrai^os
E'e`lws
E'elw`ths
'e`gchyma
'egke`falos
'egkli`nein
'egkli`tikos
'egw`
'egw`n
e'i^dos
e"i^dos
e'i`kein
e'ikoni`zein
e'iko`nos
e'i`kosi
e'ikw`n
e'ily`ein
e'i^nai
e'is
e"i`s
ek
'ek
"ek
"e-kat-on
"ekato`s
'ekba`llein
'e`kbasis
'ekbolh`
'ekdy`ein
'e`kdysis
'ekflai`nein
'e`kgonos
'ekkalei^n
'e`kkentros
'eklei`pein
'e`kleipsis
'ekleiptiko`s
'ekto`s
'e`kzema
'elachy`s
'e`laion
'e`lasma
'elay`nein
'eleei^n
'ele`fantos
'ele`fas
'elehmosy`nh
e`lei^n
'eleu`qeros
"eli`kh
"e`likos
"Elikw`n
"e`lix
'e`lkein
"e`lkein
'ellei`pein
'e`lleipsis
"E`llhnes
"e`lmins
'e`los
'Elos
'ely`ein
'e`mbolon
'e`mbryon
'eme`
'emfai`nein
'e`mfasis
'e`mmetros
'empiptein
'en
"en
"e`n
'enanti`os
'enarmoniko`s
'enarmo`nios
"e`ndeka
'e`ndon
'enegkei^n
'enne`a
'e`nnepe
"enny`nai
"eno`s
'enqetiko`s
'en-sepe
'enterokh`lh
'e`nteron
"enths
'e`ntomon
'e`ntomos
'ento`s
'e`ntosthe
-eos
"e`os
"eo`s
'epa`gein
'epagwgh`
'e`pakros
'epakto`s
'epe`chein
"e`pesqai
'epi`
'epifai`nein
'epifa`neia
'epifa`nia
'epife`rein
'epifora`
'epifwnei^n
'epifw`nhma
'epify`ein
'epi`fysis
'epi`lhptos
'epilogiko`s
'epi`machos
'epi`pedon
'epi`pedos
'epochh`
'e`pos
'e`psein
'e`pta
"epta`
"epta`chordos
'era^n
'ereyna^n
'e`rgein
'e`rgon
e`rgon
'Ermh^s trisme`gistos
"e`rpein
"e`rphs
'erwh`
'eryqro`s
'erysi`pelas
'es
"espe`ra
"e`speros
'e`spete
"esti`a
"Esti`a
'e`sw
'eswteriko`s
'esw`teros
'eteo`s
"e`teros
"etero`tropos
'e`tos
'etymologi`a
'etymologiko`n
'etymologiko`s
'e`tymon
'ex
"e`x
'exa`gein
'exagia`zein
'exa`gion
'exe`dra
"e`xis
'exorkisth`s
'exorki`zein
'exorkizmo`s
'e`xw
'exw`koitos
e'y^
e'yaggeliko`s
e'yagge`lion
e'yaggelisth`s
e'yaggeli`zesqai
e'ya`ggelos
e'y`charis
e'ycharisti`a
e'y`chlwro`s
e'yektiko`s
e'yfrai`nein
e'yfrasi`a
e'yfyh`s
e'ygenh`s
e"yri`skein
e'y`s
e'y`thktos
'e`zesthai
fagei^n
fai`nein
fai`nesqai
faino`menon
faio`s
fa`kelos
fa`lagx
fa`laina
falo`s
fa`nai
Farisai:ko`s
Farisai^os
farmakey`ein
farmakeytiko`s
fa`rmakon
farmakopoii:`a
farmakopw`lhs
fe`rbein
fe`rein
Fereni`kh
fey`gein
fh`mh
fh`r
filadelfia
fila`delfos
filei^n
fi`los
filosofi`a
fle`gein
fle`gma
fli`bein
floio`s
fobei^n
fo`bos
foini`keos
foiniko`pteros
foi`nikos
foi^nix
fonei^n
foney`s
fo`nos
forbh`
fo`ros
fqe`ggesqai
fra`gma
fra`sis
fra`ssein
fra`thr
fra`twr
fra`zein
fre`nhsis
freni^tis
frhn
frh`n
fry^ton
fw`gein
fwnei^n
fwnh`
fw^s
fwsfo`ros
fwt-
fwto`s
fy`ein
fyh`
fy`laxis
fy`llon
fy^ma
fy^nai
fyqmh`n
fysiko`s
fy`sis
fyton
fyto`n
fyto`s
gai^a
Gai^a
gai`ein
ga`la
gala`ktos
gale`h
galh^
gamei^n
gameth`
game`ths
ga`mma
ga`mos
Ganymh`dhs
ga`ros
gasth`r
gasth'r
gastro`s
ga`ta
ga`tos
gay^los
gaylo`s
gay^ros
ge`a
Ge`enna
-gen-
ge`neion
gene`qlh
geneqlhalogi`a
ge`nesis
-genh`s
ge`nos
ge`nys
gera`nion
ge`ranos
gewme`trhs
gewrgi`a
gewrgiko`s
gewrgo`s
gh^
Gh^
gh`ras
ghry`ein
gh^rys
gighw`skein
gi`gnesqai
gi`gnesthai
gignw`skein
gignw^skein
glayko`s
glay`kwma
glay`kwsis
gli`a
gloio`s
glw^ssa
glw^tta
gly`fein
glyfh`
glykero`s
glyky`rriza
glyky`s
gna`qos
gnw`mon
gnw`mwn
gnw^nai
gnw`rimos
gnw^sis
gonh`
go`nos
go`ny
Gorgei^os
Gorgo`neios
gorgo`s
Gorgw`
gra`fein
grafiko`s
gra`mma
grammai`
grammh`
gri^fos
gry`f
grypo`s
gwni`a
gymnasi`archos
gymna`sion
gymnasth`s
gymnastiko`s
gymna`zein
gymniko`s
gymno`s
gymnosofisth`s
gymno`spermos
gymo`s
gynaikei^on
gynaikei^os
gynaikokrati`a
gynaiko`s
gy`nandros
gynh`
gynh^
gy`ps
gy`psos
gy^ros
gyro`s
gyroy^n
"h^
h,
"h`bh
"H`bh
'hchh`
'h^chos
'hchw`
"h dia` pasw^n chordw^n symfoni`a
"hi`qeos
'h kolofwni`a
-hkos
'h`lektron
'hle`ktwr
"h`lios
h` Magnhsi`a li`qos
"hme`ra
"hmi-
"hmikrani`a
"hmisti`chion
"h o'ikonomi`a
"h^par
"h`patos
"h poiki`lh stoa`
'hry`ggion
'h`ryggos
'hw`s
'Hw`s
'iatrei`a
'i`chnos
'ichqyofagi`a
'ichqy`s
'ichw`r
'idei^n
'idio`morfos
'i`dios
'idioy^n
'idi`wma
'idiwmatiko`s
'idiw`ths
-i`dos
'ie`nai
"ie`nai
'ierarchi`a
"ieratiko`s
"ie`rax
"ierofa`nths
"ierofantiko`s
'iero`n
"iero`n
"iero`s
"ieroskopi`a
'Ieroysalh`m
Ihsoy^s
'ikma`s
'ikteriko`s
'i`kteros
"i`na plhrw`qh
'ini`on
'ino`s
-inqos
'i`on
'io`n
-ios
'iotakismo`s
'ipno`s
'ipo`s
"ippos
"i`ppos
"ippo`s
'i`ps
'i`s
'ischiadoko`s
'ischi`on
'ischno`s
'iso`rropos
'i`sos
'isqmo`s
'ista`nai
"ista`nai
'istori`a
"istori`a
"istoriko`s
"istoriogra`fos
"isto`s
'istwr
"istwr
'i`tis
"iw`
'Iw`
'iw`dhs
'iw`n
'iw^ta
'i`ygx
-i`zein
Ka`beiroi
kacha`zein
kachexi`a
ka`chlhx
Kadmei^os
Ka`dmos
ka`dos
kafoyra`
kai`ein
kaino`s
ka`kistos
kakka^n
kako`s
ka`lai:s
kalami`nqh
kala`minqos
kalamo`s
kalei^n
ka`llai:s
kalli-
Kallio`ph
ka`llos
kalo`s
kaly`ptein
kaly`ptra
ka`lyx
kamelay`kion
kamhlopa`rdalis
ka`mhlos
ka`nh
ka`nna
ka`nnabis
ka`nnabos
ka`nnh
kanqari`s
kanw`n
kapno`s
ka`pwn
kaqaro`s
ka`qexis
kaqoliko`s
ka`ra
kara`bi
ka`rabos
karchari`as
ka`rcharos
karda`mwmon
kardi`a
kardio-eidh`s
ka`rfos
kari`s
karki`nos
karki`nwma
ka`ron
ka`ros
karpo`s
ka`rtos
ka`ryon
kasi`a
kassi`a
kata`
kataba`sion
kata`dromos
kataklysmo`s
katalhptiko`s
katamh`nios
kata`rris
katatonos
kathchei^n
kathchoy`menos
kaylo`s
kay^ma
kaysto`s
ke`drinos
ke`dros
kefalh`
kei`rein
Ke`ltai
Keltiko`s
Keltoi`
kema`s
keno`s
kenota`fion
kentay`reion
kentayri`h
kentay`rion
ke`ntayros
Ke`ntayros
ke`ntron
ke`ramos
keranny`nai
kerao`s
ke`ras
keraso`s
kera`sths
kera`tion
ke`ratos
ke`rkos
kesto`s
key`qein
khki^dos
khki`s
kh`lh
kh^pos
kh^r
khro`s
khroy^n
kh^tos
kicha`nai
kinei^n
kinhtiko`s
kinhto`s
kiqa`ra
ki`rkos
ki`sth
ki`tron
kla`dos
kla^n
kla`zein
klei`ein
klei`s
kleitori`s
kle`os
kle`ptein
kle`pths
klh^ma
klhmati`s
klh,qra
klhriko`s
klh^ros
klh^sis
kli`nein
kli`nh
kliniko`s
klo`nos
kloph`
kly`ein
klyto`s
kni`dh
kochli`as
ko`chlos
ko`gchh
ko`i:kos
koili`a
koi^lon
koi`los
koi^los
koima^n
koino`bios
koino`s
koi`th
ko`i:x
ko`kkos
ko`lafos
ko`lfos
ko`lla
kolofw`n
Kolofw`nios
ko`lon
ko`los
ko`loyros
ko`lpos
komei^n
ko`mh
kompo`s
ko`ndylos
koni`a
koni`dos
ko`nis
koni`s
ko`pros
ko`ptein
kora`llion
ko`rax
ko`rchoros
ko`rh
ko`ris
kormo`s
ko`ros
korw`nh
korwni`s
Korybantiasmo`s
Korybantiko`s
Kory`bas
koryfh`
ko`rymbos
ko`ryza
ko`skinon
kosmiko`s
kosmitiko`s
kosmogoni`a
kosmografi`a
kosmopoli`ths
ko`smos
koy^ki
kradai`nein
krai`nein
krani`on
kra^sis
krataigo`s
kratei^n
krath`r
kra`tos
kraty`s
kre`as
kremanny`nai
kre`ws
kri`kos
kri`nein
kri`non
krio`s
kriqai`
kriqh`
krith`s
kritikh`
kritiko`s
Kritiko`s
Kroi^sos
kroko`deilos
kro`kos
kroky`s
kro`myon
Kro`nios
Kro`nos
krotei^n
kro`tos
kry`os
kry`ptein
kry`pth
kryptiko`s
krypto`n
krypto`s
kry`stallos
ktei`s
kteno`s
kwbio`s
kw^lon
kw^ma
kw`mh
kwmiko`s
kwna`rion
kwnoeidh`s
kw`nos
kw^nos
kwnwpei^on
kw`nwps
kw`ph
kya`neos
ky`anos
ky`aqos
kyberna^n
ky`biton
ky^dos
ky`ein
kyfo`s
kykla`minos
kyklami`s
kykliko`s
ky`klos
kykloy^n
Ky`klwpes
Ky`klwps
ky`klwsis
kyli`ein
kyli`ndein
kylindriko`s
ky`lindros
ky^ma
ky`mbalon
ky`mbh
ky`mbos
kynhge`ths
kynhgetikh`
kyniko`s
kyno`s
ky`ph
Ky`pris
kypse`lh
ky`ptein
kyriako`n
kyriako`s
ky`rie 'elei^son
kyriologiko`s
ky`rios
ky^ros
kyrto`s
ky`stis
ky`tos
ky`wn
labi`s
laby`rinthos
la`danon
lagw`s
laimo`s
Lakedaimo`nios
Lakedai`mwn
la`kkos
lamba`nein
la`mbda
la`mpein
lampth`r
lanqa`nein
lanqa`nesqai
lao`s
la`rix
la`ros
laryggismo`s
la`ryggos
la`rygx
la`stauros
latrei`a
latre`yein
latrey`ein
latreytiko`s
la`tris
le`chos
le`chrios
le`gein
lei`chein
leichh`n
leienteri`a
leienteriko`s
leimw`n
leimwnia`des
lei^os
lei`pein
lei`pesqai
leipoqymiko`s
lei`rion
leiro`s
le`i:tos
lei^tos
leitoyrgi`a
leka`nh
le`kiqos
le`ontos
leo`pardos
lepa`dos
lepa`s
le`pein
lepidwto`s
lepi`s
le`pisma
le`pos
le`pra
lepro`s
leptologi`a
lepto`s
Le`rnh
le`wn
lew`s
le`xasqai
lexifa`nis
lexikogra`fos
lexiko`n
lexiko`s
le`xis
Leyi:`ths
Leyitiko`s
leykofanh`s
leykoflegmati`a
leykofle`gmatos
leyko`fyllos
leyko`s
ley`kwma
lh`danon
lh^don
lh`gein
lh^mma
lhmni`skos
Lh^mnos
lh^n
lh`qaios
lhqai^os
lhqargi`a
lhqargiko`s
lh`qargos
lh`qh
liggoy`rion
ligkoy`rion
ligy`rion
li`mh
limnai^os
limo`s
li`non
liparei^n
liparo`s
lipei^n
lipogra`mmatos
lipoqymi`a
lipoqymiko`s
li`pos
liqa`rgyros
li`qeios
liqi`asis
liqiko`s
liqoglyfi`a
li`qos
li`ssesqai
lisso`s
litanei`a
litaney`ein
li`tesqai
lith`
lito`s
lito`ths
li`tra
lobo`s
lofia`
lo`fos
logaoidiko`s
lo`gchh
logikh`
logiko`s
logi`zesqai
lo`gos
-lopos
lwto`s
lychni`s
ly`chnos
ly`ein
lygkoy`rion
lygro`s
ly`gx
ly`kos
lyrismo`s
lyristh`s
ly`sis
ly`ssa
lyth`r
lyth`rios
ly`tta
ma`chaira
ma`chesqai
ma`chh
magei`a
Magnhsi`a
Magnh^tis li`qos
mai^a
Mai^a
maieytiko`s
makroda`ktylos
makro`s
ma`la
mala`chh
ma`lagma
malaki`zein
malako`s
mala`ssein
ma^llon
mallo`s
ma`lqa
ma`mma
mammo`qreptos
mammwna^s
mandh`lion
ma`ndra
mandrago`ras
mani`a
maniko`s
ma`nna
manqa`nein
mantei`a
ma`qh
maramai`rein
ma`raon
marmai`rein
ma`rmaros
ma`rsipos
marsy`pion
ma`rsypos
ma`rtyr
ma`rtys
ma`stax
ma`stigos
ma`stix
masto`s
mataiologi`a
ma`taios
mataiotechni`a
may^ros
May^ros
ma^za
mazo`s
me`
mega`lh
Mega`lh
megalo`polis
mega`loy
me`gas
meioy^n
mei`wn
mei`wsis
me`laina
melampo`dion
melana`chroos
me`lanos
me`las
me`ldein
me`li
meli`kraton
meli`mhlon
meli`nh
me`lisma
me`lissa
me`los
me`nos
Me`ntwr
meqodos
me`qy
me`rops
me`ros
mesa`raion
mesente`rion
meshmbri`a
meso`fryon
me`son
me`sos
meta`
metafe`rein
metafora`
meta`frasis
metafra`zein
meta`qesis
metatiqe`nai
me`tron
metwnymi`a
mh`
mhchanh`
mhchaniko`s
mh^chos
mhlolo`nqh
mh^lon
mhlope`pwn
mh`n
mh`nh
mh^niggos
mh^nigx
mhni`skos
mhro`s
mh`thr
mh`tra
migny`nai
mikro`s
Mi`nos
mi`nqa
mi`nqh
Minw`tayros
miny`qein
misa`nqrwpos
misei^n
mi`sgein
misogy`naios
misogy`nhs
misogyni`a
misologi`a
mi^sos
misqo`s
mi`tos
mna^sqai
mnh`mh
mnhmoniko`s
mnhmosy`nh
mnh`mwn
moi^ra
Moi^ra
molgo`s
mo`libos
mo`lybdos
mo`lybos
mona`zein
monoda`ktylos
mono`fyllos
mono`pteros
mono`ptwtos
mo`nos
monostrofiko`s
mono`strofos
mo`ra
Morfey`s
morfh`
mo`rfwsis
mormw`
mormw`n
moy`smwn
mroto`s
mwrologi`a
mw^ros
mwro`s
mw`rwsis
mychlo`s
myda^n
my`ein
myei^n
myelo`s
myi^a
myka^sqai
my`khs
mykhth`s
my`khtos
my`klos
my^kos
my`lh
myo`s
myqogra`fos
myqologi`a
myqopoio`s
my^qos
my`rmhkos
my`rmhx
Myrmido`nes
myroba`lanos
my`ron
myropw`lhs
my`rtos
my^s
my`stax
mysth`rion
my`sths
my`xa
my`zein
na`ein
na`fqa
nai:a`s
nai:`s
na^nos
nao`s
na`rdinos
na`rdos
na`rkh
na`rkissos
Na`rkissos
narkoy^n
na`rkwsis
narkwtiko`s
na`rqhx
nayarchi`a
nay`archo`s
naymachi`a
nay^s
nay`ths
naytiko`s
nayti`los
ne`ein
nefe`lh
ne`fos
nefritiko`s
nefri^tis
nefro`s
Nei^los
nekro`s
nekroy^n
ne`krwsis
Neme`h
ne`mein
Ne`mesis
ne`mos
neodamw`dhs
neo`fytos
neo`gamos
ne`os
neossia`
ne`podes
newteriko`s
new`teros
neyra`
ney^ron
nh
nhkto`s
nh^ma
nh`matos
nhmerth`s
Nhrei:`s
nhrei`ths
Nhrey`s
Nhrhi:`dos
Nhrhi:`s
nhri`ths
nhro`s
nh`sos
nh^sos
ni`fa
ni`fei
ni`ptein
no`hma
no`mos
nosokomei^on
nosos
no`sos
no`tos
No`tos
noy^s
nw^ton
nw^tos
ny`
nykta`lwps
nykto`s
ny`mfh
ny^n
ny`x
'o`asis
"o Bakchei^os
'obeli`skos
'obeli`zein
'obelo`s
'o`chlos
"odmh`
"odo`metron
"odo`metros
'odo`ntos
"odo`s
'odoy`s
'ody`nh
'Ody`sseia
'Odyssey`s
'ofio`neos
'o`fis
'ofi`ths
'ofqalmi`a
'ofqalmiko`s
'ofqalmo`s
'ofry`s
'ogdoa`dos
'ogdoa`s
'o`gkos
'Ogy`gios
oi
o'i^
o'ikei^n
o'iki`a
o'ikonomi`a
o'ikono`mos
o'i^kos
o'i`nh
o'i^nos
'o`i:s
o'isofa`gos
o'i`sw
'o`kkos
'okta-
'oktw`
'oli`gos
'olka`s
"olo`grafos
"o`los
'olympia`dos
'olympia`s
'Olympiko`s
'Oly`mpios
'O`lympos
"omalismo`s
"omalo`s
"omarh`s
'o`mbros
'omfalo`s
"Omhriko`s
'o`mma
"omo`grafos
"o`moios
'o`mona
"omo`s
'ona`gra
'o`noma
"o`noma
'ono`matos
'o`nta
'o`nychos
'o`nyma
"o`nyma
'o`nyx
"o`nyx
'o`pisqen
'o`plon
"o`plon
'opo`s
'o`ps
'o`psis
'o`psomai
'optiko`s
'o`pwpa
"o`rama
"ora^n
'ore`gein
'Oreia`s
'orektiko`s
'o`rexis
'orga^n
'o`rganon
'orgasmo`s
'o`rgia
"orismo`s
"ori`zein
"orki`zein
"o`rkos
"orma`ein
'o`rniqos
'o`rnis
'orny`nai
'o`ros
'orqo`doxos
'orqoe`peia
'orqo`s
'orykth`r
'orykto`s
'o`ryx
'o`ryza
'o`s
'osmh`
"osmh`
'o`sse
'oste`on
'ostra`kion
'ostrakismo`s
'ostraki`zein
'o`strakon
'o`streon
'ostre`on
'oura`
'oxali`s
'oxy`s
o"y^
o'yggi`a
o'ygki`a
o"y^qar
'oyra`
o'yra`
o'yrano`s
O'yrano`s
o'y^ron
o"y`ron
o'y^s
o"y^s
o'ysi`a
'o`zaina
'o`zein
'o`zwn
pa^
pa`chos
pachy`dermos
pachy`s
pagkrath`s
pagkra`tion
pa`goyros
paia`n
Paia`n
paianismo`s
paiani`zein
paidagwgi`a
paidagwgiko`s
paidagwgo`s
paidei`a
paiderasth`s
paiderasti`a
paiderastiko`s
paidey`ein
paideytikh`
paidi`on
paido`s
paidotrofi`a
pai`ein
pai^s
paiw`n
Pai`wn
paiwni`a
palaio`s
pala`mh
palillogi`a
pali`mpshston
pali`mpshstos
pa`lin
pali`ndromos
Palla`dion
Palla`dos
Palla`s
pa`llein
pa`llesqai
pa^n
Pa`n
pana`keia
pa`nakes
panakh`s
pa`nax
pandoy^ra
Pandw`ra
Panellh`nion
panhgyriko`s
panh`gyris
panhgyristh`s
panhgyri`zein
paniko`s
panopli`a
panoyrgi`a
panoyrgiko`s
panoy^rgos
pa`nqeion
pa`nqeios
pa`nqhr
panqh`ra
Pantale`wn
pantofagi`a
pantofa`gos
panto`s
pa`pyros
paqei^n
pa`qhma
paqhmatiko`s
paqhtiko`s
paqiko`s
paqopoii`:a
pa`qos
para`
paraboliko`s
para`chrwsis
paradeigmatiko`s
paradeigmati`zein
para`deisos
para`doxon
para`doxos
para`frasis
parafra`zein
para`gein
paragra`fein
para`grafos
paragwgh`
parainei^n
parai`nesis
parainetiko`s
parakalei^n
parakentei^n
parake`nthsis
para`klhtos
paraleipome`nwn
Paraleipome`nwn prw^ton
para`llhlos
paralogi`a
paralogismo`s
paralogi`zesqai
pa`ralos
paraly`ein
para`lysis
para`noia
para`sitos
pa`rdalis
pa`rdos
paregchei^n
pare`gchyma
parei^nai
pare`mptwsis
pare`nqesis
pare`nqetos
parentiqe`nai
pa`resis
paria`
paria`rchhs
parie`nai
paroiki`a
pa`roikos
paroysi`a
parqeniko`s
Parqeno`ph
parqe`nos
Parqenw`n
parw,di`a
parwnychi`a
parw`nymos
pa^s
pa`schein
pa`schei^n
pasw^n
pata`nh
patei^sthai
path`r
pa`tos
patriarchi`a
patriarchiko`s
patria`zein
pa`trios
patriw`ths
patriwtiko`s
patro`s
patrwnymiko`n
patrwnymiko`s
pay^ros
pe`dh
pe`don
pei`qein
pei^ra
peira^n
peirastiko`s
pe`kein
pela`gios
pe`lagos
pelargo`s
Pelasgo`s
pe`lein
peleka`n
peleka^n
pele`kanos
peleka^s
pe`lekys
peli`ka
pelio`s
peliwmw
pe`lla
pe`lma
pe`lth
pe`mpe
pe`mpein
penta-
penta`chordos
pentada`ktylos
penta`dos
penta`gwnon
penta`s
pe`nte
pepai`nein
pe`peri
pepli`s
pe`plos
pe`psis
pe`ptein
peptiko`s
pepto`s
pe`pwn
perai^os
pe`rdix
peri`
Peri` li`qwn
pe`rkh
perkno`s
pe`rna
pe`ssein
pe`talon
pe`tesqai
pe`tra
petrai^os
petri`s
pe`tros
Pe`tros
petrose`linon
ph`dhsis
Ph`gasos
phgh`
ph^gma
phgny`nai
phkto`s
Phnelo`ph
phni`on
ph^nos
pi^
pi^dax
pidy`ein
pi^los
pimelh`
pi`nax
pi`peri
pi`ptein
pi`qhkos
pi`son
pi`sos
pi`ssa
pi`syres
pi`tta
pi`wn
pla`gios
plagto`n
plagto`s
plako`s
pla`sma
pla`ssein
plastiko`s
platei^a
platy`s
pla`x
pla`zesqai
plei^n
pley`mwn
pleyra`
pleyri^tis
pleyro`qen
plh`rhs
plh`ssein
plw`ein
pnei^n
pney^ma
pney`matos
pney`mones
pneymoni`a
pney`mwn
po`a
podo`s
pohfa`gos
poiei^n
poihth`s
poihtiko`s
poiki`los
poinh`
poiw^n
polio`s
po`lis
poli`ths
po`ltos
poly`anqos
poly`glwttos
poly`gwnos
poly`s
poly`technos
po`nos
porei^n
porfy`ra
po`rkos
po`ros
po`sis
po`sqh
po`teros
po`tos
poy`s
poy^ stw^
praiko`kia
pra`ttein
pri`ein
pri`sma
pri`zein
pro`
progignw`skein
pro`gnosis
prognwstiko`n
progra`fein
pro`gramma
Pro`knh
pro`swpon
protaktiko`s
pro`tasis
prota`ssein
protatiko`s
protei`nein
pro`teros
prwkto`s
prwtagonisth`s
prwtei^on
prw`tistos
prw^tos
psey`dein
pseydh`s
pseydo`doxos
psh^n
psychh`
PSychh`
psychro`s
psydro`s
psy`qos
ptero`n
ptery`gion
pte`rygos
pte`ryx
pte`sqai
pugh`
pw`gwn
pwlei^n
pw^los
pw^ma
pygh`
pygmh`
pykno`s
pynqa`nesqai
py`on
pyqmh`n
py^r
pyro`s
pyrso`s
py`x
pyxi`s
py`xos
qa`lamos
qa`lassa
Qa`leia
qa`llein
qa`mnos
qa`natos
qay^ma
qay`matos
qaymatourgi`a
qaymatourgo`s
qeandriko`s
qei^chos
qei`nein
qe`mis
qe`os
qeo`s
Qeoy^ Gio`s
qeoyrgi`a
qeoyrgo`s
qerapey`ein
qe`rma
qermai`nein
qe`rmh
qermo`s
qe`ros
qh`kh
qhlh`
qh^lys
qh`r
qhra^n
qhri`on
qhro`s
qh^sai
qh^sqai
qh^ta
qli`bein
qo`los
qri`x
qry^los
qy`ein
qyflo`s
qyga`thr
qy`mon
qy`mos
qymo`s
qy`nnos
qy^nos
qy`os
qy`ra
qyreoeidh`s
qyreo`s
"r
"rabbi`
"ra`bdos
"ra`bdwma
"ra`chis
"rachi^tis
"rafh`
"ra`fys
"rago`s
"raka`
"ra`mfos
"ra`mnos
"rapsw,di`a
"rapsw,diko`s
"rapsw,do`s
"ra`ptein
"ra`pys
"ra`x
"rei^n
"re`mbein
"re`zein
"rhgny`nai
"rhti`nh
"rh`twr
"rinoke`rws
"rinoke`rwtos
"rino`s
"ri`s
'ri`za
"ri`za
"rodo`dendron
"ro`don
"Romai^oi
"ro`mbos
"roph`
"rwtaki`zein
"ry`gchos
"ryparo`s
"ry`pos
"ry`sis
"ryti`s
sa`bbaton
sa`gos
sa`kkos
sa`ntalon
sapro`s
sarkasmo`s
sarka`zein
sarkofagi`a
sarkofa`gos
sa`rkos
sa`rx
Sata^n
Satana^s
satyriko`s
saty`rion
sau^ros
say^ros
schedia`zein
schi`sma
schi`zein
sei`ein
seirh`n
seismo`s
selh`nh
se`linon
sfa`llein
sfh`n
sfi`ggein
sfi`gx
sfy`raina
sh^ma
shmantikos
shmasi`a
sh`matos
shmei^on
shmeiwtiko`s
si`alon
si`oyros
sitei^n
sitos
ska`fh
skalhno`s
skammwni`a
skandali`zein
ska`ptein
ska`rifos
ska`ros
ska`zein
ska`zwn
ske`ptesqai
skeptiko`s
skhnh`
skia`
sklhro`s
skolio`s
skoly`ptein
sko`mbros
skopei^n
skopo`s
skoti`a
sko`tos
skw`lhx
skw`ptein
skwptiko`s
sky`balon
sky`fos
sky`tos
smerdale`os
smerdno`s
smi`lh
sminy`h
sofia
sofi`a
sofisth`s
sofo`s
So`loi
soloikismo`s
soloiki`zein
so`loikos
somfo`s
spa`n
spa^n
spa`qh
sparga^n
spei`rein
spe`rchesqai
spe`rma
spi`ggos
spinqari`s
splh`n
splhniko`s
splhni^tis
spodo`s
spoggia`
spoggi`on
spo`ggos
spora`des
spo`ros
sqe`nos
sta`dion
stafi`s
stafylh`
stafy`linos
stafyli^nos
stafy`lwma
stakth`
stakto`s
sta`lagma
stalakto`s
stala`zein
sta`qmh
sta`simon
sta`simos
sta`sis
stath`r
statikh`
statiko`s
stato`s
stayro`s
stayrwto`s
sta`zein
ste`ar
ste`atos
steatoy^n
stea`twma
stegano`podos
stegano`poys
stegano`s
ste`gein
ste`gh
stegno`s
stegnoy^n
ste`gnwsis
stegnwtiko`s
stei^ra
stei^ros
steleo`n
ste`llein
steno`s
stereo`s
sth`mwn
sth^nai
sth^qos
stichiko`s
sti`chos
stilpno`s
sti`mmi
stoa`
stochastiko`s
stocha`zesqai
sto`chos
sto`ma
sto`machos
sto`matos
strofh`
sty`ein
sty`fein
Stygo`s
styli`ths
styloba`ths
sty`los
sty^los
sty`pph
Sty`x
sw^ma
swmatiko`s
sw`matos
swrei`ths
swro`s
swth`r
Swth`r
swthri`a
swth`rios
sw`zein
sy`
sy`llhpsis
syllogismo`s
syllogi`zesqai
symba`llein
symbioy^n
symbi`wsis
symbiwtiko`s
symboliko`s
sy`mbolon
sympo`sion
sy`n
syndyasmo`s
syndya`zein
synekdochh`
sy`nodos
synw`nymon
sy^s
syzygi`a
tachino`s
ta`chistos
ta`chos
tachy`s
ta`fos
ta~ gewrgika`
taini`a
ta` katamh`nia
taktika`
taktikh`
taktiko`s
talanton
ta~ mnhmonika`
tampa`rion
Ta`ntalos
ta` o'ikonomika`
tarakto`s
tara`ssein
Ta`rtaros
ta`sis
ta`ssein
ta`ta
ta`ttein
taw`s
taw^s
ta`xis
tay^
tayro`kolla
tayromachi`a
tay^ros
te`chnh
tei^chos
tei`nein
teiqein
te`knon
te`ktwn
teleos
te`leos
teley`th
te`mnein
te`nwn
tere`binqos
te`rminqos
te`rsesqai
tesai`nein
te`sares
te`ssares
te`tra-
te`tracha
tetra`drachmon
tetra`dymos
tetra`gwnon
tetraplo`os
tetraploy^s
te`tta
te`ttares
tharrei^n
tharsei^n
tharsy`s
thermo`s
th`kein
th^le
thy`ra
ti^fos
ti`gris
ti`ktein
ti`llein
tilmo`s
ti-qe`-nai
tiqe`nai
tlh^nai
tmh^sis
to`kos
tolna^n
tomh`
to`mos
tomo`s
to`nos
to~ pa^n
to~ paniko`n
topa`zion
to`pazos
topika`
topiko`s
to`poi
to`pos
to`rnos
toxiko`n
toxiko`s
to`xon
trachei^a
tragh`mata
tre`chein
tre`fein
trei^s
tre`pein
trhto`s
tri-
tri`bein
tri`cha
tricho`s
tri`kokkos
trilogi`a
tri`tonos
tri`tos
Tri`twn
tri`x
trocho`s
trofh`
troph`
trw`gein
trw`kths
Trwo`s
Trw`s
turo`s
ty`
ty`chh
tyflo`s
ty^fos
tyfw^n
tyfw^s
ty`lh
ty`los
tympanisth`s
tympani`ths
tympani`zein
ty`mpanon
ty`panon
ty`pos
ty`ptein
tyranni`a
tyranni`s
tyranni`zein
ty`rannoi
ty`rannos
w,
'w,a`rion
'w,dh`
'wkeano`s
'wky`s
'w^ me`ga
'wmofa`gos
'w^mos
'wmo`s
-w`nh
'w^nos
'w,o`n
w,'o`n
'wpo`s
'w`ps
"w`ps
'wqei^n
'Wri`wn
"ws
'w^sis
'wsmo`s
'wti`das
'wto`s
xa`nqion
xanqo`s
xenhlasi`a
xe`nion
xe`non
xe`nos
xhw`ra
xifi`as
xi`fos
xy`lon
xysth`r
"y`alos
"y`datos
"y`dra
"ydra`rgyros
"y`dros
'y`dwr
"y`dwr
"yeto`s
"yfai`nein
"yf "e`n
"yfe`n
"yfh`
"y`fos
"ygro`s
"y`lh
"ymei^s
"ymh`n
-y`os
"ype`r
"yperw`,n
"ypo
"ypo`
"ypokri`nesqai
"ypo`krisis
'y^ psilo`n
"y^s
"yste`ra
"y`steros
"y`strix
zabo`s
zape`tion
ze`a
zeia`
zei^n
zeygny`nai
Zey`s
zh^los
zh^n
zi`zyfon
zwh`
zw`nh
zwnny`nai
zw^,on
zw,on
zy`gon
zygo`n
zy`mh
zy^qos
_ATEOF


cat >expout <<'_ATEOF'
ἀ
ἀ-
ᾳ
ἀβακίσκος
ἄβαξ
ἀββᾶς
Ἀβδηρίτης
ἀχάτης
ἄχνη
ἄχος
ἀδάμας
ἀδελφός
ἀδηφάγος
ᾅδης
ἄδνη
-άδος
ἁδρός
Ἄδωνις
ἀείδειν
ἄφλαστον
ἄφως
ἄφωτος
ἀγαλακτία
άγάλλοχον
ἄγαλμα
ἄγαλματος
ἄγαμος
ἀγάπαι
ἀγάπη
ἄγχειν
ἄγειν
άγελος
ἄγγαρος
ἀγγεῖον
ἄγγελειν
ἄγγελος
ἀγγούριον
ἀγήρατον
ἁγιόγραφα
ἁγιόγραφος
ἄγιος
ἄγκος
ἀγκών
ἀγκύλος
ἄγκυρα
ἄγνοια
ἀγνύναι
ἀγονιστής
ἀγορά
ἄγριος
ἀγωγός
ἀγών
ἄγυρις
ἀῆναι
ἀήρ
ἀήτης
αι
Ὰἰδης
αἱ κόλουροι
ἀῖμα
αἶμα
αἷμα
αἱματικός
αἵματος
αἱμάτωσις
αἱμορραγία
αἱμορραγικός
αἴνιγμα
αἰνίσσεσθαι
αἶνος
Αἰολικός
Αἰολίς
αἴθειν
αἰθήρ
αἶθος
αἴρειν
αἰων
ἄκανθα
ἀκέφαλος
ἀκεῖσθαι
ἀκή
ἀκινητος
ἄκμων
ἀκούειν
ακρασια
ἀκρολίθος
ἄκρον
ἀκρόνυχος
ἀκρόνυκτος
ἀκρόπολις
ἄκρος
ἀκρότομος
ἀκρωτήριον
ἀλάβαστρος
ἀλαός
ἀλέγειν
ἄλφα
ἄλγησις
ἄλγος
ἁλιευτικός
ἀλκή
ἄλκιμος
ἀλκυόνιον
ἀλκυών
ἁλκυών
ἄλλεσθαι
ἀλλότριος
ἄλμα
ἀλόη
ἁλός
-άλου
ἄλς
ἁλτῆρες
ἄλων
ἄλωνος
ἀλωπεκία
ἀλώπηξ
ἄλως
ἄλυσις
ἄλυσσον
ἄμα
Ὰμαδρυάς
ἁμαμηλίς
ἀμᾶν
ἀμάρακον
ἀμάρακος
ἄμβιξ
ἄμβροτος
ἀμείβειν
ἀμέλγειν
ἄμεναι
ἀμέργειν
ἀμφί
ἀμφιβάλλειν
ἀμφίβιος
ἀμφιβολία
ἀμφίβολος
ἀμφίδρομος
ἄμφω
ἀμήν
ἀμμίτης
ἀμμίτις
ἁμμόχρυσος
ἄμμος
ἄμμος
ἀμνησία
ἀμόργης
ἀμπελῖτις
ἄμπελος
ἀμυγδάλη
ἄμυος
ἀν
ἀνά
ἀναβαπτισμός
ἀναβαπτιστής
ἀναφέρειν
ἀναφορά
ἀναγράφειν
ἀναγραφή
ἀναγραμματισμός
ἀναγραμματίζειν
ἀναιμία
ἀναλαμβάνειν
ἀναλέγειν
ἀνάλεκτα
ἀναλγησία
ἀνάλημμα
ἀναλκής
ἀνάμνησις
ἄναρθρος
ἀνασταλτικός
ἀνδήρ
ἀνδροειδής
ἀνδροφάγος
ἀνδρός
ανδρός
ἀνδρών
ἄνεμος
ἄνηθον
ἀνήρ
ανήρ
ἄνισον
ἄνισος
ἄνοπλος
-ανος
ἀνθεῖν
ἀνθεμίς
ἀνθολόγος
ἀνθόλοψ
ἄνθος
ἀνθρήνη
ἀνθροποφυής
ἄνθροπος
ἄνθρωπος
ἀντί
ἀντίδοτον
ἀντίδοτος
ἀντίφωνα
ἀντίφωνον
ἀντίφωνος
ἀντιλογία
ἀντίλογος
ἄντοικι
-αντος
ἄνω
ἀνωφελής
ἀοιδή
ἀοριστικός
ἀόριστος
ἁπλόος
απο
ἀπό
ἀποφάναι
ἀπόφασις
ἀποφεύγειν
ἀποφθέγγεσθαι
ἀπόφθεγμα
ἀποφθεγματικός
ἀποφυγή
ἀποπέμπειν
ἀποπεμπτικός
ἀποπλήσσειν
ἀποπληξία
ἁψῖδος
ἁψίς
ἄπτειν
ἀπωτέρω
ἀθανασία
ἀθάνατος
Ἀθηνᾶ
Ἀθηνάα
Ἀθηναία
Ἀθηναίν
Ἀθηναίον
Ἀθήνη
ἀραιά
ἀραιός
ἀρχ-
ἀρχάγγελος
ἀρχαϊκός
ἀρχαιολογία
ἀρχαῖος
ἀρχαϊσμός
ἀρχαῒζειν
ἀρχε
ἄρχειν
ἀρχέτυπον
ἀρχέτυπος
ἀρχη
ἀρχή
ἀρχι
ἀρχι-
ἀρχιεπίσκοπος
ἀρχικός
ἀρχός
ἄρχων
ἀργής
ἀργός
ἄργυρος
ἀριθμός
ἀρκεῖν
ἁρμονία
ἁρμονικός
ἁρμός
ἁρμοστής
ἁρμόζειν
ἁρπάγη
ἀρπάζειν
ἁρπάζειν
ἄρπη
ἄρπυια
ἀρθριτικός
ἀρθρίτις
ἀρθρῖτις
ἄρθρον
ἀρραβών
ἀρρενικόν
ἀρρενικός
ἄρρην
ἀρσενικόν
ἀρσενικός
ἄρσις
Ἄρτεμις
Ἀρτεμισία
ἀρτηρία
ἆσαι
ἄσαρον
ἀσφάραγος
ἀσφόδελος
ἀσκηθής
ἀσκός
ἀσπάραγος
ἀσπίς
ἄσπρον
ἄσπρος
ἀσθένια
ἀσθενικός
ἀστερίας
ἀστέριον
ἀστήρ
ἀστρολάβον
ἀστρολογία
ἀστρολογικός
ἀστρολόγος
ἄστρον
ἀστρονομικός
ἀταραξία
-ατος
ἀξίνη
ἄξων
αὕειν
αὐγή
αὐγίτης
αὐτοπτικός
αὐτός
ἄυως
βαίνειν
βαίτυλος
Βακχικός
Βάκχος
βακτήριον
βάκτρον
βαλάνι
βαλανιά
βαλανίδι
βαλανιδιά
βάλανος
βαλαύστιον
βαλεῖν
βαλιαρεῖς
βάλλειν
βαλλίζειν
βαλσαμίνη
βάλσαμον
βαμβαίνειν
βαμβαλίζειν
βάπτειν
βάπτισμα
βαπτιστήριον
βαπτιστής
βαπτιστικός
βαπτίζειν
βάθος
βαθός
βαθύς
βαρβαρικός
βαρβαρισμός
βάρβαρος
βάρβιτον
βάρος
βαρύς
βαρύτης
βαρύτονος
βάσανος
βασιλεῖαι
βασιλεύς
βασιλική
βασιλικόν
βασιλικός
βασιλίσκος
βάσις
βαστάζειν
βάτης
βάτος
βατράχειος
βατραχομυομαχία
βάτραχος
βαττολογία
βάττος
βδέλλα
βδέλλιον
βένθος
Βερενίκη
Βερονίκη
βήρυλλος
βῆτα
βιβλία
βιβλιογραφία
βιβλίον
βίβλιον γεωργικόν
βίβλος
βιβρώσκειν
βῖκος
βίος
βιοῦν
βίσων
βιῶν
βίωσις
βιωτικός
βλαψίφημος
βλάψις
βλάπτειν
βλασφημεῖν
βλάσφημος
βλαστάνειν
βλάστημα
βλαστικός
βλαστός
βλέψις
βλίτον
βόαξ
βολβός
βομβυλιός
βοός
Βόσπορος
βουβών
βοώτης
βούκερως
βουλιμία
βούς
βοῦς
βούτυρον
βράχιστος
βραχύς
βράγχιον
βρέχειν
βρεχμός
βρέγμα
βρόχθος
βροντή
βροτός
βρῶμα
βρύειν
βρῦτον
βρυωνία
βῶξ
βύβλος
βύρσα
βύσσινος
βύσσος
χα
χαβαζίος
χάινειν
χαίνειν
χαίρειν
χαίτη
χάλκανθος
Χαλκηδών
χαλκίς
χαλκός
χαμαί
χαμαιλέων
χαμαίμηλον
χανδάνειν
χάος
χάρις
χάρυβδις
χάσμα
χειά
χεῖν
χείρ
χειρός
χελιδόνιος
χελιδών
χελώνη
χερσόνησος
χέρσος
χηλή
χήν
χήρ
χίασμα
χιασμός
χιαστός
χιάζειν
χιλιαδός
χιλιάς
χίλιοι
χλαμύδος
χλαμύς
χλόν
χλωρός
χοάνη
χολάδες
χόνδρος
χορδή
χόριον
χόρτος
χορτός
χρίειν
χρῖσμα
Χριστός
ΧΡΙΣΤΟΣ
χρόα
χροά
Χρόνος
χρῶμα
χρώς
χρυσόκολλα
χρυσός
χώρα
χῶρος
χυλοποιεῖν
χυλός
δάφνη
Δαγών
δαήρ
δαιμονικός
δαίμων
δάκνειν
δάκρυ
δάκρυμα
δάκρυον
δακτυλικός
δακτυλιογλύφος
δακτύλιος
δάκτυλος
δαμᾷν
Δαμασκός
δᾶμος
δαρεικός
δασύς
δέησις
δεικνύναι
δεικτικός
δεῖμα
δεῖν
δεινός
δεῖπνον
δειπνοσοφιστής
δέκα
δεκάχορδος
δέκατος
Δελφικός
δελφίν
δελφίς
Δελφοί
δελφύς
δέλτα
δελτοειδής
δενδρίτης
δενδρῖτις
δένδρον
δέρειν
δέρκεσθαι
δέρμα
δερμηστής
δέρος
δέσμη
δεσμός
δεσπότης
δεσποτικός
δεύτερον
δεύτερος
δηλεῖσθαι
δηλητήριος
δημαγωγία
δημαγωγός
δημαγωκικός
δήμαρχος
δήμιος
δημιουργικός
δημιουργός
δημοκρατία
δῆμος
δημοτικός
δηνάριον
δι
δι-
διά
διακλᾶν
διάκονος
διαπασῶν
διάπεντε
διάρρεῖν
διάρροια
διατέμνειν
διάτομος
δίδαξις
διδόναι
δίδυμος
διφυής
δικαστήριον
δικαστής
δικάζειν
δικέφαλος
δικεῖν
δίκη
δίκταμνον
δίκταμνος
δῖος
Διός
δι-πλάσιος
διπλόος
δις
δίς
δίσ-
δίσκος
δισσολογία
διττολογία
δόγμα
δόγματα
δογματικός
δοκεῖν
δολερός
δολιχός
δόμος
δόρυ
δόσις
δόξα
δοῦλος
δραχμή
δράκειν
δράκων
δρᾶμα
δραματικός
δραμεῖν
δρᾶν
δράσσεσθαι
δριμύς
δρομάς
δρόμος
δρόμων
δροσερός
δρόσος
δρύππα
δρῦς
δῶρον
δύειν
δυναστεία
δυναστεύειν
δυνάστης
δύο
δυσ-
δυσκρασία
δυσπρόσιτος
ἔ
ἔαρ
ἑβδομάς
ἔχειν
ἔχιδνα
ἐχῖνος
ἔχις
ἔδειν
ἔδρα
ἕδρα
ἑδραῖος
Εἔλως
Εἐλώτης
ἔγχυμα
ἐγκέφαλος
ἐγκλίνειν
ἐγκλίτικος
ἐγώ
ἐγών
εἶδος
εἷδος
εἴκειν
εἰκονίζειν
εἰκόνος
εἴκοσι
εἰκών
εἰλύειν
εἶναι
εἰς
εἵς
εκ
ἐκ
ἑκ
ἑ-κατ-ον
ἑκατός
ἐκβάλλειν
ἔκβασις
ἐκβολή
ἐκδύειν
ἔκδυσις
ἐκφλαίνειν
ἔκγονος
ἐκκαλεῖν
ἔκκεντρος
ἐκλείπειν
ἔκλειψις
ἐκλειπτικός
ἐκτός
ἔκζεμα
ἐλαχύς
ἔλαιον
ἔλασμα
ἐλαύνειν
ἐλεεῖν
ἐλέφαντος
ἐλέφας
ἐλεημοσύνη
έλεῖν
ἐλεύθερος
ἑλίκη
ἕλικος
Ὲλικών
ἕλιξ
ἔλκειν
ἕλκειν
ἐλλείπειν
ἔλλειψις
Ἕλληνες
ἕλμινς
ἔλος
Ἐλος
ἐλύειν
ἔμβολον
ἔμβρυον
ἐμέ
ἐμφαίνειν
ἔμφασις
ἔμμετρος
ἐμπιπτειν
ἐν
ἑν
ἕν
ἐναντίος
ἐναρμονικός
ἐναρμόνιος
ἕνδεκα
ἔνδον
ἐνεγκεῖν
ἐννέα
ἔννεπε
ἑννύναι
ἑνός
ἐνθετικός
ἐν-σεπε
ἐντεροκήλη
ἔντερον
ἑντης
ἔντομον
ἔντομος
ἐντός
ἔντοστηε
-εος
ἕος
ἑός
ἐπάγειν
ἐπαγωγή
ἔπακρος
ἐπακτός
ἐπέχειν
ἕπεσθαι
ἐπί
ἐπιφαίνειν
ἐπιφάνεια
ἐπιφάνια
ἐπιφέρειν
ἐπιφορά
ἐπιφωνεῖν
ἐπιφώνημα
ἐπιφύειν
ἐπίφυσις
ἐπίληπτος
ἐπιλογικός
ἐπίμαχος
ἐπίπεδον
ἐπίπεδος
ἐποχή
ἔπος
ἔψειν
ἔπτα
ἑπτά
ἑπτάχορδος
ἐρᾶν
ἐρευνᾶν
ἔργειν
ἔργον
έργον
Ἐρμῆσ τρισμέγιστος
ἕρπειν
ἕρπης
ἐρωή
ἐρυθρός
ἐρυσίπελας
ἐς
ἑσπέρα
ἕσπερος
ἔσπετε
ἑστία
Ὲστία
ἔσω
ἐσωτερικός
ἐσώτερος
ἐτεός
ἕτερος
ἑτερότροπος
ἔτος
ἐτυμολογία
ἐτυμολογικόν
ἐτυμολογικός
ἔτυμον
ἐξ
ἕξ
ἐξάγειν
ἐξαγιάζειν
ἐξάγιον
ἐξέδρα
ἕξις
ἐξορκιστής
ἐξορκίζειν
ἐξορκιζμός
ἔξω
ἐξώκοιτος
εὖ
εὐαγγελικός
εὐαγγέλιον
εὐαγγελιστής
εὐαγγελίζεσθαι
εὐάγγελος
εὔχαρις
εὐχαριστία
εὔχλωρός
εὐεκτικός
εὐφραίνειν
εὐφρασία
εὐφυής
εὐγενής
εὑρίσκειν
εὔς
εὔτηκτος
ἔζεστηαι
φαγεῖν
φαίνειν
φαίνεσθαι
φαινόμενον
φαιός
φάκελος
φάλαγξ
φάλαινα
φαλός
φάναι
Φαρισαϊκός
Φαρισαῖος
φαρμακεύειν
φαρμακευτικός
φάρμακον
φαρμακοποιῒα
φαρμακοπώλης
φέρβειν
φέρειν
Φερενίκη
φεύγειν
φήμη
φήρ
φιλαδελφια
φιλάδελφος
φιλεῖν
φίλος
φιλοσοφία
φλέγειν
φλέγμα
φλίβειν
φλοιός
φοβεῖν
φόβος
φοινίκεος
φοινικόπτερος
φοίνικος
φοῖνιξ
φονεῖν
φονεύς
φόνος
φορβή
φόρος
φθέγγεσθαι
φράγμα
φράσις
φράσσειν
φράτηρ
φράτωρ
φράζειν
φρένησις
φρενῖτις
φρην
φρήν
φρῦτον
φώγειν
φωνεῖν
φωνή
φῶς
φωσφόρος
φωτ-
φωτός
φύειν
φυή
φύλαξις
φύλλον
φῦμα
φῦναι
φυθμήν
φυσικός
φύσις
φυτον
φυτόν
φυτός
γαῖα
Γαῖα
γαίειν
γάλα
γαλάκτος
γαλέη
γαλῆ
γαμεῖν
γαμετή
γαμέτης
γάμμα
γάμος
Γανυμήδης
γάρος
γαστήρ
γαστηῤ
γαστρός
γάτα
γάτος
γαῦλος
γαυλός
γαῦρος
γέα
Γέεννα
-γεν-
γένειον
γενέθλη
γενεθληαλογία
γένεσις
-γενής
γένος
γένυς
γεράνιον
γέρανος
γεωμέτρης
γεωργία
γεωργικός
γεωργός
γῆ
Γῆ
γήρας
γηρύειν
γῆρυς
γιγηώσκειν
γίγνεσθαι
γίγνεστηαι
γιγνώσκειν
γιγνῶσκειν
γλαυκός
γλαύκωμα
γλαύκωσις
γλία
γλοιός
γλῶσσα
γλῶττα
γλύφειν
γλυφή
γλυκερός
γλυκύρριζα
γλυκύς
γνάθος
γνώμον
γνώμων
γνῶναι
γνώριμος
γνῶσις
γονή
γόνος
γόνυ
Γοργεῖος
Γοργόνειος
γοργός
Γοργώ
γράφειν
γραφικός
γράμμα
γραμμαί
γραμμή
γρῖφος
γρύφ
γρυπός
γωνία
γυμνασίαρχος
γυμνάσιον
γυμναστής
γυμναστικός
γυμνάζειν
γυμνικός
γυμνός
γυμνοσοφιστής
γυμνόσπερμος
γυμός
γυναικεῖον
γυναικεῖος
γυναικοκρατία
γυναικός
γύνανδρος
γυνή
γυνῆ
γύψ
γύψος
γῦρος
γυρός
γυροῦν
ἧ
ῃ
ἤβη
Ἥβη
ἠχή
ἦχος
ἠχώ
ἡ διά πασῶν χορδῶν συμφονία
ἡίθεος
ἠ κολοφωνία
-ηκος
῎ηλεκτρον
ἠλέκτωρ
ἤλιος
ή Μαγνησία λίθος
ἡμέρα
ἡμι-
ἡμικρανία
ἡμιστίχιον
ἡ οἰκονομία
ἧπαρ
ἤπατος
ἡ ποικίλη στοά
ἠρύγγιον
῎ηρυγγος
ἠώς
Ἠώς
ἰατρεία
ἴχνος
ἰχθυοφαγία
ἰχθύς
ἰχώρ
ἰδεῖν
ἰδιόμορφος
ἴδιος
ἰδιοῦν
ἰδίωμα
ἰδιωματικός
ἰδιώτης
-ίδος
ἰέναι
ἱέναι
ἰεραρχία
ἱερατικός
ἱέραξ
ἱεροφάντης
ἱεροφαντικός
ἰερόν
ἱερόν
ἱερός
ἱεροσκοπία
Ἰερουσαλήμ
Ιησοῦς
ἰκμάς
ἰκτερικός
ἴκτερος
ἵνα πληρώθη
ἰνίον
ἰνός
-ινθος
ἴον
ἰόν
-ιος
ἰοτακισμός
ἰπνός
ἰπός
ἱππος
ἵππος
ἱππός
ἴψ
ἴς
ἰσχιαδοκός
ἰσχίον
ἰσχνός
ἰσόρροπος
ἴσος
ἰσθμός
ἰστάναι
ἱστάναι
ἰστορία
ἱστορία
ἱστορικός
ἱστοριογράφος
ἱστός
ἰστωρ
ἱστωρ
ἴτις
ἱώ
Ἰώ
ἰώδης
ἰών
ἰῶτα
ἴυγξ
-ίζειν
Κάβειροι
καχάζειν
καχεξία
κάχληξ
Καδμεῖος
Κάδμος
κάδος
καφουρά
καίειν
καινός
κάκιστος
κακκᾶν
κακός
κάλαϊς
καλαμίνθη
καλάμινθος
καλαμός
καλεῖν
κάλλαϊς
καλλι-
Καλλιόπη
κάλλος
καλός
καλύπτειν
καλύπτρα
κάλυξ
καμελαύκιον
καμηλοπάρδαλις
κάμηλος
κάνη
κάννα
κάνναβις
κάνναβος
κάννη
κανθαρίς
κανών
καπνός
κάπων
καθαρός
κάθεξις
καθολικός
κάρα
καράβι
κάραβος
καρχαρίας
κάρχαρος
καρδάμωμον
καρδία
καρδιο-ειδής
κάρφος
καρίς
καρκίνος
καρκίνωμα
κάρον
κάρος
καρπός
κάρτος
κάρυον
κασία
κασσία
κατά
καταβάσιον
κατάδρομος
κατακλυσμός
καταληπτικός
καταμήνιος
κατάρρις
κατατονος
κατηχεῖν
κατηχούμενος
καυλός
καῦμα
καυστός
κέδρινος
κέδρος
κεφαλή
κείρειν
Κέλται
Κελτικός
Κελτοί
κεμάς
κενός
κενοτάφιον
κενταύρειον
κενταυρίη
κενταύριον
κένταυρος
Κένταυρος
κέντρον
κέραμος
κεραννύναι
κεραός
κέρας
κερασός
κεράστης
κεράτιον
κέρατος
κέρκος
κεστός
κεύθειν
κηκῖδος
κηκίς
κήλη
κῆπος
κῆρ
κηρός
κηροῦν
κῆτος
κιχάναι
κινεῖν
κινητικός
κινητός
κιθάρα
κίρκος
κίστη
κίτρον
κλάδος
κλᾶν
κλάζειν
κλείειν
κλείς
κλειτορίς
κλέος
κλέπτειν
κλέπτης
κλῆμα
κληματίς
κλῃθρα
κληρικός
κλῆρος
κλῆσις
κλίνειν
κλίνη
κλινικός
κλόνος
κλοπή
κλύειν
κλυτός
κνίδη
κοχλίας
κόχλος
κόγχη
κόϊκος
κοιλία
κοῖλον
κοίλος
κοῖλος
κοιμᾶν
κοινόβιος
κοινός
κοίτη
κόϊξ
κόκκος
κόλαφος
κόλφος
κόλλα
κολοφών
Κολοφώνιος
κόλον
κόλος
κόλουρος
κόλπος
κομεῖν
κόμη
κομπός
κόνδυλος
κονία
κονίδος
κόνις
κονίς
κόπρος
κόπτειν
κοράλλιον
κόραξ
κόρχορος
κόρη
κόρις
κορμός
κόρος
κορώνη
κορωνίς
Κορυβαντιασμός
Κορυβαντικός
Κορύβας
κορυφή
κόρυμβος
κόρυζα
κόσκινον
κοσμικός
κοσμιτικός
κοσμογονία
κοσμογραφία
κοσμοπολίτης
κόσμος
κοῦκι
κραδαίνειν
κραίνειν
κρανίον
κρᾶσις
κραταιγός
κρατεῖν
κρατήρ
κράτος
κρατύς
κρέας
κρεμαννύναι
κρέως
κρίκος
κρίνειν
κρίνον
κριός
κριθαί
κριθή
κριτής
κριτική
κριτικός
Κριτικός
Κροῖσος
κροκόδειλος
κρόκος
κροκύς
κρόμυον
Κρόνιος
Κρόνος
κροτεῖν
κρότος
κρύος
κρύπτειν
κρύπτη
κρυπτικός
κρυπτόν
κρυπτός
κρύσταλλος
κτείς
κτενός
κωβιός
κῶλον
κῶμα
κώμη
κωμικός
κωνάριον
κωνοειδής
κώνος
κῶνος
κωνωπεῖον
κώνωψ
κώπη
κυάνεος
κύανος
κύαθος
κυβερνᾶν
κύβιτον
κῦδος
κύειν
κυφός
κυκλάμινος
κυκλαμίς
κυκλικός
κύκλος
κυκλοῦν
Κύκλωπες
Κύκλωψ
κύκλωσις
κυλίειν
κυλίνδειν
κυλινδρικός
κύλινδρος
κῦμα
κύμβαλον
κύμβη
κύμβος
κυνηγέτης
κυνηγετική
κυνικός
κυνός
κύπη
Κύπρις
κυψέλη
κύπτειν
κυριακόν
κυριακός
κύριε ἐλεῖσον
κυριολογικός
κύριος
κῦρος
κυρτός
κύστις
κύτος
κύων
λαβίς
λαβύριντηος
λάδανον
λαγώς
λαιμός
Λακεδαιμόνιος
Λακεδαίμων
λάκκος
λαμβάνειν
λάμβδα
λάμπειν
λαμπτήρ
λανθάνειν
λανθάνεσθαι
λαός
λάριξ
λάρος
λαρυγγισμός
λάρυγγος
λάρυγξ
λάσταυρος
λατρεία
λατρέυειν
λατρεύειν
λατρευτικός
λάτρις
λέχος
λέχριος
λέγειν
λείχειν
λειχήν
λειεντερία
λειεντερικός
λειμών
λειμωνιάδες
λεῖος
λείπειν
λείπεσθαι
λειποθυμικός
λείριον
λειρός
λέϊτος
λεῖτος
λειτουργία
λεκάνη
λέκιθος
λέοντος
λεόπαρδος
λεπάδος
λεπάς
λέπειν
λεπιδωτός
λεπίς
λέπισμα
λέπος
λέπρα
λεπρός
λεπτολογία
λεπτός
Λέρνη
λέων
λεώς
λέξασθαι
λεξιφάνις
λεξικογράφος
λεξικόν
λεξικός
λέξις
Λευῒτης
Λευιτικός
λευκοφανής
λευκοφλεγματία
λευκοφλέγματος
λευκόφυλλος
λευκός
λεύκωμα
λήδανον
λῆδον
λήγειν
λῆμμα
λημνίσκος
Λῆμνος
λῆν
λήθαιος
ληθαῖος
ληθαργία
ληθαργικός
λήθαργος
λήθη
λιγγούριον
λιγκούριον
λιγύριον
λίμη
λιμναῖος
λιμός
λίνον
λιπαρεῖν
λιπαρός
λιπεῖν
λιπογράμματος
λιποθυμία
λιποθυμικός
λίπος
λιθάργυρος
λίθειος
λιθίασις
λιθικός
λιθογλυφία
λίθος
λίσσεσθαι
λισσός
λιτανεία
λιτανεύειν
λίτεσθαι
λιτή
λιτός
λιτότης
λίτρα
λοβός
λοφιά
λόφος
λογαοιδικός
λόγχη
λογική
λογικός
λογίζεσθαι
λόγος
-λοπος
λωτός
λυχνίς
λύχνος
λύειν
λυγκούριον
λυγρός
λύγξ
λύκος
λυρισμός
λυριστής
λύσις
λύσσα
λυτήρ
λυτήριος
λύττα
μάχαιρα
μάχεσθαι
μάχη
μαγεία
Μαγνησία
Μαγνῆτισ λίθος
μαῖα
Μαῖα
μαιευτικός
μακροδάκτυλος
μακρός
μάλα
μαλάχη
μάλαγμα
μαλακίζειν
μαλακός
μαλάσσειν
μᾶλλον
μαλλός
μάλθα
μάμμα
μαμμόθρεπτος
μαμμωνᾶς
μανδήλιον
μάνδρα
μανδραγόρας
μανία
μανικός
μάννα
μανθάνειν
μαντεία
μάθη
μαραμαίρειν
μάραον
μαρμαίρειν
μάρμαρος
μάρσιπος
μαρσύπιον
μάρσυπος
μάρτυρ
μάρτυς
μάσταξ
μάστιγος
μάστιξ
μαστός
ματαιολογία
μάταιος
ματαιοτεχνία
μαῦρος
Μαῦρος
μᾶζα
μαζός
μέ
μεγάλη
Μεγάλη
μεγαλόπολις
μεγάλου
μέγας
μειοῦν
μείων
μείωσις
μέλαινα
μελαμπόδιον
μελανάχροος
μέλανος
μέλας
μέλδειν
μέλι
μελίκρατον
μελίμηλον
μελίνη
μέλισμα
μέλισσα
μέλος
μένος
Μέντωρ
μεθοδος
μέθυ
μέροψ
μέρος
μεσάραιον
μεσεντέριον
μεσημβρία
μεσόφρυον
μέσον
μέσος
μετά
μεταφέρειν
μεταφορά
μετάφρασις
μεταφράζειν
μετάθεσις
μετατιθέναι
μέτρον
μετωνυμία
μή
μηχανή
μηχανικός
μῆχος
μηλολόνθη
μῆλον
μηλοπέπων
μήν
μήνη
μῆνιγγος
μῆνιγξ
μηνίσκος
μηρός
μήτηρ
μήτρα
μιγνύναι
μικρός
Μίνος
μίνθα
μίνθη
Μινώταυρος
μινύθειν
μισάνθρωπος
μισεῖν
μίσγειν
μισογύναιος
μισογύνης
μισογυνία
μισολογία
μῖσος
μισθός
μίτος
μνᾶσθαι
μνήμη
μνημονικός
μνημοσύνη
μνήμων
μοῖρα
Μοῖρα
μολγός
μόλιβος
μόλυβδος
μόλυβος
μονάζειν
μονοδάκτυλος
μονόφυλλος
μονόπτερος
μονόπτωτος
μόνος
μονοστροφικός
μονόστροφος
μόρα
Μορφεύς
μορφή
μόρφωσις
μορμώ
μορμών
μούσμων
μροτός
μωρολογία
μῶρος
μωρός
μώρωσις
μυχλός
μυδᾶν
μύειν
μυεῖν
μυελός
μυῖα
μυκᾶσθαι
μύκης
μυκητής
μύκητος
μύκλος
μῦκος
μύλη
μυός
μυθογράφος
μυθολογία
μυθοποιός
μῦθος
μύρμηκος
μύρμηξ
Μυρμιδόνες
μυροβάλανος
μύρον
μυροπώλης
μύρτος
μῦς
μύσταξ
μυστήριον
μύστης
μύξα
μύζειν
νάειν
νάφθα
ναϊάς
ναῒς
νᾶνος
ναός
νάρδινος
νάρδος
νάρκη
νάρκισσος
Νάρκισσος
ναρκοῦν
νάρκωσις
ναρκωτικός
νάρθηξ
ναυαρχία
ναύαρχός
ναυμαχία
ναῦς
ναύτης
ναυτικός
ναυτίλος
νέειν
νεφέλη
νέφος
νεφριτικός
νεφρῖτις
νεφρός
Νεῖλος
νεκρός
νεκροῦν
νέκρωσις
Νεμέη
νέμειν
Νέμεσις
νέμος
νεοδαμώδης
νεόφυτος
νεόγαμος
νέος
νεοσσιά
νέποδες
νεωτερικός
νεώτερος
νευρά
νεῦρον
νη
νηκτός
νῆμα
νήματος
νημερτής
Νηρεῒς
νηρείτης
Νηρεύς
Νηρηῒδος
Νηρηῒς
νηρίτης
νηρός
νήσος
νῆσος
νίφα
νίφει
νίπτειν
νόημα
νόμος
νοσοκομεῖον
νοσος
νόσος
νότος
Νότος
νοῦς
νῶτον
νῶτος
νύ
νυκτάλωψ
νυκτός
νύμφη
νῦν
νύξ
ὄασις
ὁ Βακχεῖος
ὀβελίσκος
ὀβελίζειν
ὀβελός
ὄχλος
ὁδμή
ὁδόμετρον
ὁδόμετρος
ὀδόντος
ὁδός
ὀδούς
ὀδύνη
Ὀδύσσεια
Ὀδυσσεύς
ὀφιόνεος
ὄφις
ὀφίτης
ὀφθαλμία
ὀφθαλμικός
ὀφθαλμός
ὀφρύς
ὀγδοάδος
ὀγδοάς
ὄγκος
Ὀγύγιος
οι
οἶ
οἰκεῖν
οἰκία
οἰκονομία
οἰκονόμος
οἶκος
οἴνη
οἶνος
ὄϊς
οἰσοφάγος
οἴσω
ὄκκος
ὀκτα-
ὀκτώ
ὀλίγος
ὀλκάς
ὁλόγραφος
ὅλος
ὀλυμπιάδος
ὀλυμπιάς
Ὀλυμπικός
Ὀλύμπιος
Ὄλυμπος
ὁμαλισμός
ὁμαλός
ὁμαρής
ὄμβρος
ὀμφαλός
Ὸμηρικός
ὄμμα
ὁμόγραφος
ὅμοιος
ὄμονα
ὁμός
ὀνάγρα
ὄνομα
ὅνομα
ὀνόματος
ὄντα
ὄνυχος
ὄνυμα
ὅνυμα
ὄνυξ
ὅνυξ
ὄπισθεν
ὄπλον
ὅπλον
ὀπός
ὄψ
ὄψις
ὄψομαι
ὀπτικός
ὄπωπα
ὅραμα
ὁρᾶν
ὀρέγειν
Ὀρειάς
ὀρεκτικός
ὄρεξις
ὀργᾶν
ὄργανον
ὀργασμός
ὄργια
ὁρισμός
ὁρίζειν
ὁρκίζειν
ὅρκος
ὁρμάειν
ὄρνιθος
ὄρνις
ὀρνύναι
ὄρος
ὀρθόδοξος
ὀρθοέπεια
ὀρθός
ὀρυκτήρ
ὀρυκτός
ὄρυξ
ὄρυζα
ὄς
ὀσμή
ὁσμή
ὄσσε
ὀστέον
ὀστράκιον
ὀστρακισμός
ὀστρακίζειν
ὄστρακον
ὄστρεον
ὀστρέον
ὀυρά
ὀξαλίς
ὀξύς
οὗ
οὐγγία
οὐγκία
οὗθαρ
ὀυρά
οὐρά
οὐρανός
Οὐρανός
οὖρον
οὕρον
οὖς
οὗς
οὐσία
ὄζαινα
ὄζειν
ὄζων
πᾶ
πάχος
παχύδερμος
παχύς
παγκρατής
παγκράτιον
πάγουρος
παιάν
Παιάν
παιανισμός
παιανίζειν
παιδαγωγία
παιδαγωγικός
παιδαγωγός
παιδεία
παιδεραστής
παιδεραστία
παιδεραστικός
παιδεύειν
παιδευτική
παιδίον
παιδός
παιδοτροφία
παίειν
παῖς
παιών
Παίων
παιωνία
παλαιός
παλάμη
παλιλλογία
παλίμψηστον
παλίμψηστος
πάλιν
παλίνδρομος
Παλλάδιον
Παλλάδος
Παλλάς
πάλλειν
πάλλεσθαι
πᾶν
Πάν
πανάκεια
πάνακες
πανακής
πάναξ
πανδοῦρα
Πανδώρα
Πανελλήνιον
πανηγυρικός
πανήγυρις
πανηγυριστής
πανηγυρίζειν
πανικός
πανοπλία
πανουργία
πανουργικός
πανοῦργος
πάνθειον
πάνθειος
πάνθηρ
πανθήρα
Πανταλέων
παντοφαγία
παντοφάγος
παντός
πάπυρος
παθεῖν
πάθημα
παθηματικός
παθητικός
παθικός
παθοποιῒα
πάθος
παρά
παραβολικός
παράχρωσις
παραδειγματικός
παραδειγματίζειν
παράδεισος
παράδοξον
παράδοξος
παράφρασις
παραφράζειν
παράγειν
παραγράφειν
παράγραφος
παραγωγή
παραινεῖν
παραίνεσις
παραινετικός
παρακαλεῖν
παρακεντεῖν
παρακέντησις
παράκλητος
παραλειπομένων
Παραλειπομένων πρῶτον
παράλληλος
παραλογία
παραλογισμός
παραλογίζεσθαι
πάραλος
παραλύειν
παράλυσις
παράνοια
παράσιτος
πάρδαλις
πάρδος
παρεγχεῖν
παρέγχυμα
παρεῖναι
παρέμπτωσις
παρένθεσις
παρένθετος
παρεντιθέναι
πάρεσις
παριά
παριάρχης
παριέναι
παροικία
πάροικος
παρουσία
παρθενικός
Παρθενόπη
παρθένος
Παρθενών
παρῳδία
παρωνυχία
παρώνυμος
πᾶς
πάσχειν
πάσχεῖν
πασῶν
πατάνη
πατεῖστηαι
πατήρ
πάτος
πατριαρχία
πατριαρχικός
πατριάζειν
πάτριος
πατριώτης
πατριωτικός
πατρός
πατρωνυμικόν
πατρωνυμικός
παῦρος
πέδη
πέδον
πείθειν
πεῖρα
πειρᾶν
πειραστικός
πέκειν
πελάγιος
πέλαγος
πελαργός
Πελασγός
πέλειν
πελεκάν
πελεκᾶν
πελέκανος
πελεκᾶς
πέλεκυς
πελίκα
πελιός
πελιωμω
πέλλα
πέλμα
πέλτη
πέμπε
πέμπειν
πεντα-
πεντάχορδος
πενταδάκτυλος
πεντάδος
πεντάγωνον
πεντάς
πέντε
πεπαίνειν
πέπερι
πεπλίς
πέπλος
πέψις
πέπτειν
πεπτικός
πεπτός
πέπων
περαῖος
πέρδιξ
περί
Περί λίθων
πέρκη
περκνός
πέρνα
πέσσειν
πέταλον
πέτεσθαι
πέτρα
πετραῖος
πετρίς
πέτρος
Πέτρος
πετροσέλινον
πήδησις
Πήγασος
πηγή
πῆγμα
πηγνύναι
πηκτός
Πηνελόπη
πηνίον
πῆνος
πῖ
πῖδαξ
πιδύειν
πῖλος
πιμελή
πίναξ
πίπερι
πίπτειν
πίθηκος
πίσον
πίσος
πίσσα
πίσυρες
πίττα
πίων
πλάγιος
πλαγτόν
πλαγτός
πλακός
πλάσμα
πλάσσειν
πλαστικός
πλατεῖα
πλατύς
πλάξ
πλάζεσθαι
πλεῖν
πλεύμων
πλευρά
πλευρῖτις
πλευρόθεν
πλήρης
πλήσσειν
πλώειν
πνεῖν
πνεῦμα
πνεύματος
πνεύμονες
πνευμονία
πνεύμων
πόα
ποδός
ποηφάγος
ποιεῖν
ποιητής
ποιητικός
ποικίλος
ποινή
ποιῶν
πολιός
πόλις
πολίτης
πόλτος
πολύανθος
πολύγλωττος
πολύγωνος
πολύς
πολύτεχνος
πόνος
πορεῖν
πορφύρα
πόρκος
πόρος
πόσις
πόσθη
πότερος
πότος
πούς
ποῦ στῶ
πραικόκια
πράττειν
πρίειν
πρίσμα
πρίζειν
πρό
προγιγνώσκειν
πρόγνοσις
προγνωστικόν
προγράφειν
πρόγραμμα
Πρόκνη
πρόσωπον
προτακτικός
πρότασις
προτάσσειν
προτατικός
προτείνειν
πρότερος
πρωκτός
πρωταγονιστής
πρωτεῖον
πρώτιστος
πρῶτος
ψεύδειν
ψευδής
ψευδόδοξος
ψῆν
ψυχή
Ψυχή
ψυχρός
ψυδρός
ψύθος
πτερόν
πτερύγιον
πτέρυγος
πτέρυξ
πτέσθαι
πυγή
πώγων
πωλεῖν
πῶλος
πῶμα
πυγή
πυγμή
πυκνός
πυνθάνεσθαι
πύον
πυθμήν
πῦρ
πυρός
πυρσός
πύξ
πυξίς
πύξος
θάλαμος
θάλασσα
Θάλεια
θάλλειν
θάμνος
θάνατος
θαῦμα
θαύματος
θαυματουργία
θαυματουργός
θεανδρικός
θεῖχος
θείνειν
θέμις
θέος
θεός
Θεοῦ Γιός
θεουργία
θεουργός
θεραπεύειν
θέρμα
θερμαίνειν
θέρμη
θερμός
θέρος
θήκη
θηλή
θῆλυς
θήρ
θηρᾶν
θηρίον
θηρός
θῆσαι
θῆσθαι
θῆτα
θλίβειν
θόλος
θρίξ
θρῦλος
θύειν
θυφλός
θυγάτηρ
θύμον
θύμος
θυμός
θύννος
θῦνος
θύος
θύρα
θυρεοειδής
θυρεός
ῥ
ῥαββί
ῥάβδος
ῥάβδωμα
ῥάχις
ῥαχῖτις
ῥαφή
ῥάφυς
ῥαγός
ῥακά
ῥάμφος
ῥάμνος
ῥαψῳδία
ῥαψῳδικός
ῥαψῳδός
ῥάπτειν
ῥάπυς
ῥάξ
ῥεῖν
ῥέμβειν
ῥέζειν
ῥηγνύναι
ῥητίνη
ῥήτωρ
ῥινοκέρως
ῥινοκέρωτος
ῥινός
ῥίς
ῤίζα
ῥίζα
ῥοδόδενδρον
ῥόδον
Ῥομαῖοι
ῥόμβος
ῥοπή
ῥωτακίζειν
ῥύγχος
ῥυπαρός
ῥύπος
ῥύσις
ῥυτίς
σάββατον
σάγος
σάκκος
σάνταλον
σαπρός
σαρκασμός
σαρκάζειν
σαρκοφαγία
σαρκοφάγος
σάρκος
σάρξ
Σατᾶν
Σατανᾶς
σατυρικός
σατύριον
σαῦρος
σαῦρος
σχεδιάζειν
σχίσμα
σχίζειν
σείειν
σειρήν
σεισμός
σελήνη
σέλινον
σφάλλειν
σφήν
σφίγγειν
σφίγξ
σφύραινα
σῆμα
σημαντικος
σημασία
σήματος
σημεῖον
σημειωτικός
σίαλον
σίουρος
σιτεῖν
σιτος
σκάφη
σκαληνός
σκαμμωνία
σκανδαλίζειν
σκάπτειν
σκάριφος
σκάρος
σκάζειν
σκάζων
σκέπτεσθαι
σκεπτικός
σκηνή
σκιά
σκληρός
σκολιός
σκολύπτειν
σκόμβρος
σκοπεῖν
σκοπός
σκοτία
σκότος
σκώληξ
σκώπτειν
σκωπτικός
σκύβαλον
σκύφος
σκύτος
σμερδαλέος
σμερδνός
σμίλη
σμινύη
σοφια
σοφία
σοφιστής
σοφός
Σόλοι
σολοικισμός
σολοικίζειν
σόλοικος
σομφός
σπάν
σπᾶν
σπάθη
σπαργᾶν
σπείρειν
σπέρχεσθαι
σπέρμα
σπίγγος
σπινθαρίς
σπλήν
σπληνικός
σπληνῖτις
σποδός
σπογγιά
σπογγίον
σπόγγος
σποράδες
σπόρος
σθένος
στάδιον
σταφίς
σταφυλή
σταφύλινος
σταφυλῖνος
σταφύλωμα
στακτή
στακτός
στάλαγμα
σταλακτός
σταλάζειν
στάθμη
στάσιμον
στάσιμος
στάσις
στατήρ
στατική
στατικός
στατός
σταυρός
σταυρωτός
στάζειν
στέαρ
στέατος
στεατοῦν
στεάτωμα
στεγανόποδος
στεγανόπους
στεγανός
στέγειν
στέγη
στεγνός
στεγνοῦν
στέγνωσις
στεγνωτικός
στεῖρα
στεῖρος
στελεόν
στέλλειν
στενός
στερεός
στήμων
στῆναι
στῆθος
στιχικός
στίχος
στιλπνός
στίμμι
στοά
στοχαστικός
στοχάζεσθαι
στόχος
στόμα
στόμαχος
στόματος
στροφή
στύειν
στύφειν
Στυγός
στυλίτης
στυλοβάτης
στύλος
στῦλος
στύππη
Στύξ
σῶμα
σωματικός
σώματος
σωρείτης
σωρός
σωτήρ
Σωτήρ
σωτηρία
σωτήριος
σώζειν
σύ
σύλληψις
συλλογισμός
συλλογίζεσθαι
συμβάλλειν
συμβιοῦν
συμβίωσις
συμβιωτικός
συμβολικός
σύμβολον
συμπόσιον
σύν
συνδυασμός
συνδυάζειν
συνεκδοχή
σύνοδος
συνώνυμον
σῦς
συζυγία
ταχινός
τάχιστος
τάχος
ταχύς
τάφος
τὰ γεωργικά
ταινία
τά καταμήνια
τακτικά
τακτική
τακτικός
ταλαντον
τὰ μνημονικά
ταμπάριον
Τάνταλος
τά οἰκονομικά
ταρακτός
ταράσσειν
Τάρταρος
τάσις
τάσσειν
τάτα
τάττειν
ταώς
ταῶς
τάξις
ταῦ
ταυρόκολλα
ταυρομαχία
ταῦρος
τέχνη
τεῖχος
τείνειν
τειθειν
τέκνον
τέκτων
τελεος
τέλεος
τελεύτη
τέμνειν
τένων
τερέβινθος
τέρμινθος
τέρσεσθαι
τεσαίνειν
τέσαρες
τέσσαρες
τέτρα-
τέτραχα
τετράδραχμον
τετράδυμος
τετράγωνον
τετραπλόος
τετραπλοῦς
τέττα
τέτταρες
τηαρρεῖν
τηαρσεῖν
τηαρσύς
τηερμός
τήκειν
τῆλε
τηύρα
τῖφος
τίγρις
τίκτειν
τίλλειν
τιλμός
τι-θέ-ναι
τιθέναι
τλῆναι
τμῆσις
τόκος
τολνᾶν
τομή
τόμος
τομός
τόνος
τὸ πᾶν
τὸ πανικόν
τοπάζιον
τόπαζος
τοπικά
τοπικός
τόποι
τόπος
τόρνος
τοξικόν
τοξικός
τόξον
τραχεῖα
τραγήματα
τρέχειν
τρέφειν
τρεῖς
τρέπειν
τρητός
τρι-
τρίβειν
τρίχα
τριχός
τρίκοκκος
τριλογία
τρίτονος
τρίτος
Τρίτων
τρίξ
τροχός
τροφή
τροπή
τρώγειν
τρώκτης
Τρωός
Τρώς
τυρός
τύ
τύχη
τυφλός
τῦφος
τυφῶν
τυφῶς
τύλη
τύλος
τυμπανιστής
τυμπανίτης
τυμπανίζειν
τύμπανον
τύπανον
τύπος
τύπτειν
τυραννία
τυραννίς
τυραννίζειν
τύραννοι
τύραννος
ῳ
ᾠάριον
ᾠδή
ὠκεανός
ὠκύς
ὦ μέγα
ὠμοφάγος
ὦμος
ὠμός
-ώνη
ὦνος
ᾠόν
ῳὄν
ὠπός
ὤψ
ὥψ
ὠθεῖν
Ὠρίων
ὡς
ὦσις
ὠσμός
ὠτίδας
ὠτός
ξάνθιον
ξανθός
ξενηλασία
ξένιον
ξένον
ξένος
ξηώρα
ξιφίας
ξίφος
ξύλον
ξυστήρ
ὕαλος
ὕδατος
ὕδρα
ὑδράργυρος
ὕδρος
ὔδωρ
ὕδωρ
ὑετός
ὑφαίνειν
ὑφ ἕν
ὑφέν
ὑφή
ὕφος
ὑγρός
ὕλη
ὑμεῖς
ὑμήν
-ύος
ὑπέρ
ὑπερῴν
ὑπο
ὑπό
ὑποκρίνεσθαι
ὑπόκρισις
ὖ ψιλόν
ὗς
ὑστέρα
ὕστερος
ὕστριξ
ζαβός
ζαπέτιον
ζέα
ζειά
ζεῖν
ζευγνύναι
Ζεύς
ζῆλος
ζῆν
ζίζυφον
ζωή
ζώνη
ζωννύναι
ζῷον
ζῳον
ζύγον
ζυγόν
ζύμη
ζῦθος
_ATEOF


{ set +x
$as_echo "$at_srcdir/greek.at:5548: greek < input"
at_fn_check_prepare_trace "greek.at:5548"
( $at_check_trace; greek < input
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/greek.at:5548"
$at_failed && at_fn_log_failure
$at_traceon; }


  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_3
#AT_START_4
at_fn_group_banner 4 'idx.at:17' \
  "idxgcide" "                                       " 1
at_xfail=no
(
  $as_echo "4. $at_setup_line: testing $at_desc ..."
  $at_traceon


{ set +x
$as_echo "$at_srcdir/idx.at:19: idxgcide \$DICTDIR .||exit \$?
find . -name GCIDE.IDX
"
at_fn_check_prepare_notrace 'an embedded newline' "idx.at:19"
( $at_check_trace; idxgcide $DICTDIR .||exit $?
find . -name GCIDE.IDX

) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "./GCIDE.IDX
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/idx.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }


  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_4
#AT_START_5
at_fn_group_banner 5 'autoidx.at:17' \
  "Automatic indexing" "                             " 1
at_xfail=no
(
  $as_echo "5. $at_setup_line: testing $at_desc ..."
  $at_traceon



{ set +x
$as_echo "$at_srcdir/autoidx.at:20: rm -f \$IDXDIR/GCIDE.IDX
echo \"quit\" | dicod --config \$abs_builddir/dicod.conf --stderr -i 2>&1 |  tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//;s|'\"\$IDXDIR\"'/*||'
"
at_fn_check_prepare_notrace 'an embedded newline' "autoidx.at:20"
( $at_check_trace; rm -f $IDXDIR/GCIDE.IDX
echo "quit" | dicod --config $abs_builddir/dicod.conf --stderr -i 2>&1 |  tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//;s|'"$IDXDIR"'/*||'

) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "dicod: Notice: gcide_open_idx: creating index GCIDE.IDX
220
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/autoidx.at:20"
$at_failed && at_fn_log_failure
$at_traceon; }


  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_5
#AT_START_6
at_fn_group_banner 6 'descr.at:17' \
  "descr" "                                          " 2
at_xfail=no
(
  $as_echo "6. $at_setup_line: testing $at_desc ..."
  $at_traceon




cat >input <<'_ATEOF'
show db
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/descr.at:20: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "descr.at:20"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
110 1 databases present
gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/descr.at:20"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_6
#AT_START_7
at_fn_group_banner 7 'info.at:17' \
  "info" "                                           " 2
at_xfail=no
(
  $as_echo "7. $at_setup_line: testing $at_desc ..."
  $at_traceon




cat >input <<'_ATEOF'
show info gcide
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/info.at:20: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "info.at:20"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
112 information for gcide
A mock GCIDE dictionary for GNU Dico test suite.

GNU Dico is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GNU Dico is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Dico.  If not, see <http://www.gnu.org/licenses/>.

.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/info.at:20"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_7
#AT_START_8
at_fn_group_banner 8 'exact.at:17' \
  "exact" "                                          " 3
at_xfail=no
(
  $as_echo "8. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
match gcide exact madman
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/exact.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "exact.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
152 1 matches found: list follows
gcide \"Madman\"
.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/exact.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_8
#AT_START_9
at_fn_group_banner 9 'prefix.at:17' \
  "prefix" "                                         " 3
at_xfail=no
(
  $as_echo "9. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
match gcide prefix ja
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/prefix.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "prefix.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
152 2 matches found: list follows
gcide \"Jabberwocky\"
gcide \"January\"
.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/prefix.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_9
#AT_START_10
at_fn_group_banner 10 'all.at:17' \
  "all" "                                            " 3
at_xfail=no
(
  $as_echo "10. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
match gcide all ""
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/all.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "all.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
152 60 matches found: list follows
gcide \"aardvark\"
gcide \"Abandon\"
gcide \"Adjective\"
gcide \"Atlantes\"
gcide \"Babel\"
gcide \"Bloom\"
gcide \"Bottle\"
gcide \"C\"
gcide \"camel\"
gcide \"Cyclic\"
gcide \"Cyclical\"
gcide \"database\"
gcide \"Double\"
gcide \"Ed\"
gcide \"Edit\"
gcide \"Emacs\"
gcide \"Enumeration\"
gcide \"File\"
gcide \"Float\"
gcide \"FORTRAN\"
gcide \"GNU\"
gcide \"Grammar\"
gcide \"Gyroscopic\"
gcide \"Hack\"
gcide \"Help\"
gcide \"Integer\"
gcide \"Iteration\"
gcide \"Jabberwocky\"
gcide \"January\"
gcide \"kludge\"
gcide \"long\"
gcide \"loop\"
gcide \"macro\"
gcide \"Madman\"
gcide \"Name\"
gcide \"Negation\"
gcide \"not\"
gcide \"Occident\"
gcide \"Odd\"
gcide \"Offset\"
gcide \"Page\"
gcide \"Pooh\"
gcide \"PROLOG\"
gcide \"Q\"
gcide \"Recursion\"
gcide \"seek\"
gcide \"Static\"
gcide \"tee\"
gcide \"telamones\"
gcide \"Transpose\"
gcide \"Transposition\"
gcide \"UNIX\"
gcide \"unsigned\"
gcide \"value\"
gcide \"vi\"
gcide \"while\"
gcide \"x\"
gcide \"yank\"
gcide \"zap\"
gcide \"Zawinski's Law\"
.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/all.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_10
#AT_START_11
at_fn_group_banner 11 'def00.at:17' \
  "define (single entry)" "                          " 4
at_xfail=no
(
  $as_echo "11. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
define gcide GNU
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/def00.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "def00.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
150 1 definitions found: list follows
151 \"GNU\" gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
GNU n. GNU's Not UNIX.

[Dico testsuite]


.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/def00.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_11
#AT_START_12
at_fn_group_banner 12 'def01.at:17' \
  "define (multiple entries)" "                      " 4
at_xfail=no
(
  $as_echo "12. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
define gcide kludge
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/def01.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "def01.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
150 2 definitions found: list follows
151 \"kludge\" gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
kludge n. A working solution, not particularly elegant.

[Dico testsuite]


.
151 \"kludge\" gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
kludge v. To use such a solution.

[Dico testsuite]




.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/def01.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_12
#AT_START_13
at_fn_group_banner 13 'def02.at:17' \
  "double-bar handling" "                            " 4
at_xfail=no
(
  $as_echo "13. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
define gcide atlantes
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/def02.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "def02.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
150 1 definitions found: list follows
151 \"atlantes\" gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
‖Atlantes, n. pl. A definition with alternate name telamones.

[Dico testsuite]




.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/def02.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_13
#AT_START_14
at_fn_group_banner 14 'def04.at:17' \
  "mhw" "                                            " 4
at_xfail=no
(
  $as_echo "14. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
define gcide cyclic
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/def04.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "def04.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
150 1 definitions found: list follows
151 \"cyclic\" gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
{ Cyclic, Cyclical} a.
[Gr. κυκλικός, fr. κύκλος See {Cycle}.]
Going in cycles

[Dico testsuite]





.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/def04.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_14
#AT_START_15
at_fn_group_banner 15 'def05.at:17' \
  "mhw (second definition)" "                        " 4
at_xfail=no
(
  $as_echo "15. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
define gcide cyclical
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/def05.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "def05.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
150 1 definitions found: list follows
151 \"cyclical\" gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
{ Cyclic, Cyclical} a.
[Gr. κυκλικός, fr. κύκλος See {Cycle}.]
Going in cycles

[Dico testsuite]





.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/def05.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_15
#AT_START_16
at_fn_group_banner 16 'def06.at:17' \
  "first entry in page" "                            " 4
at_xfail=no
(
  $as_echo "16. $at_setup_line: testing $at_desc ..."
  $at_traceon



cat >input <<'_ATEOF'
define gcide aardvark
quit
_ATEOF

{ set +x
$as_echo "$at_srcdir/def06.at:19: dicod --config \$abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\\r' | sed 's/^\\(2[25][0-9]\\) .*/\\1/;s/ *\$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2"
at_fn_check_prepare_notrace 'an embedded newline' "def06.at:19"
( $at_check_trace; dicod --config $abs_builddir/dicod.conf --stderr -i < input 2>err |     tr -d '\r' | sed 's/^\(2[25][0-9]\) .*/\1/;s/ *$//'
sed '/Notice: gcide_open_idx: creating index/d' err >&2
) >>"$at_stdout" 2>>"$at_stderr" 5>&-
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "220
150 1 definitions found: list follows
151 \"aardvark\" gcide \"A mock GCIDE dictionary for GNU Dico test suite\"
aardvark (ärdvärk), n. [D., earth-pig.] (Zoöl.) Aardvark is an animal.

[Dico testsuite]


.
250
221
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/def06.at:19"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_16
