#!/bin/sh
#                                                      -*- coding: latin-1 -*-
# Validation suite for the Free `recode' program and library.
# Copyright  1998, 1999 Progiciels Bourbeau-Pinard inc.
# Franois Pinard <pinard@iro.umontreal.ca>, 1998.

# Still many parts of `recode' are not exercised by the test suite.  A few
# FIXME's, below, are used to list tests that we would need.  Do you feel
# like contributing new tests?  If you do, you may tell your intent to
# `recode-forum@iro.umontreal.ca', so no two people work at the same thing.

. ./atconfig
# Snippet (3

at_usage="Usage: $0 OPTION...

  -e  Stop and inhibit normal clean up if a test of the full test suite fails
  -n  Do not redirect stdout and stderr and do not test their contents
  -s  Inhibit verbosity in debugging scripts, at generation or at execution
  -v  Force more detailed output, default for debugging scripts unless -s
  -x  Have the shell to trace command execution; implies options -a"

while test $# -gt 0; do
  case "$1" in
    -e) at_stop_on_error=1; shift ;;
    -n) at_no_redirs=1; shift ;;
    -s) at_verbose=; at_silent=1; shift ;;
    -v) at_verbose=1; at_silent=; shift ;;
    -x) at_tracex=1; at_no_redirs=1; shift ;;
    *) echo 1>&2 "$at_usage"; exit 1 ;;
  esac
done

# In the testing suite, we only want to know if the test succeeded or failed.
# But in debugging scripts, we want more information, so we prefer `diff -u'
# to silent `cmp', even if it may happen that we compare binary files.
# Option `-u' might be less portable, so either change it or use GNU `diff'.

if test -n "$at_verbose"; then
  at_diff='diff -u'
else
  if test -n "$COMSPEC$ComSpec"; then
    at_diff='diff -u'
  else
    at_diff='cmp -s'
  fi
fi

# Each generated debugging script, containing a single test group, cleans
# up files at the beginning only, not at the end.  This is so we can repeat
# the script many times and browse left over files.  To cope with such left
# over files, the full test suite cleans up both before and after test groups.
# Snippet )3

if test -n "`recode --version | sed -n s/$at_package.*$at_version/OK/p`"; then
  at_banner="Testing suite for $at_package, version $at_version"
  at_dashes=`echo $at_banner | sed s/./=/g`
  echo "$at_dashes"
  echo "$at_banner"
  echo "$at_dashes"
else
  echo '======================================================='
  echo 'ERROR: Not using the proper version, no tests performed'
  echo '======================================================='
  exit 1
fi

# Remove any debugging script resulting from a previous run.
rm -f debug-*.sh

at_failed_list=
at_ignore_count=0

# Tell the installer that `make bigtest' exists.
echo
echo "WARNING: The \`bigauto' test will be skipped, as it takes a long time to"
echo "         complete.  To launch it, get into the build \`tests/' directory"
echo "         and do either \`make bigtest' or \`make bigtest-strict'.  The"
echo "         later forces \`-s' on all \`recode' calls."

echo
echo 'Charset listings.'
echo

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c1(

rm -rf stdout stderr expout
# Snippet )c1)
  echo names.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing list of charsets and surfaces'
    echo $at_n "     $at_c"
  fi
  echo $at_n "1. $srcdir/names.m4:3         $at_c"
  (
# Snippet (s1(

# The test group starts at `names.m4:3'.  An error occurred while
# testing list of charsets and surfaces.

cat >expout <<'EOF'
/21-Permutation swabytes
/4321-Permutation
/Base64 64 b64
/CR
/CR-LF cl
/data
/Decimal-1 d d1
/Decimal-2 d2
/Decimal-4 d4
/Hexadecimal-1 x x1
/Hexadecimal-2 x2
/Hexadecimal-4 x4
/Octal-1 o o1
/Octal-2 o2
/Octal-4 o4
/Quoted-Printable QP quote-printable
/test7
/test8
/test15
/test16
AFRFUL-102-BPI_OCIL bambara bra ewondo fulfulde
AFRFUL-103-BPI_OCIL t-bambara t-bra t-ewondo t-fulfulde
AFRL1-101-BPI_OCIL t-fra t-francais
AFRLIN-104-BPI_OCIL lin lingala sango wolof
AFRLIN-105-BPI_OCIL t-lin t-lingala t-sango t-wolof
ANSI_X3.4-1968 367/CR-LF ANSI_X3.4-1986 ASCII CP367/CR-LF IBM367/CR-LF ISO646-US iso-ir-6 ISO_646.irv:1991 us US-ASCII
Apple-Mac/CR
ASCII-BS BS
ASMO_449 arabic7 iso-ir-89 ISO_9036
AtariST
baltic iso-ir-179
Bang-Bang
BS_4730 gb ISO646-GB iso-ir-4 uk
BS_viewdata iso-ir-47
CDC-NOS NOS
combined-UCS-2 co
CORK T1
count-characters
CP1250/CR-LF 1250/CR-LF ms-ee windows-1250
CP1251/CR-LF 1251/CR-LF ms-cyrl windows-1251
CP1252/CR-LF 1252/CR-LF ms-ansi windows-1252
CP1253/CR-LF 1253/CR-LF ms-greek windows-1253
CP1254/CR-LF 1254/CR-LF ms-turk windows-1254
CP1255/CR-LF 1255/CR-LF ms-hebr windows-1255
CP1256/CR-LF 1256/CR-LF ms-arab windows-1256
CP1257/CR-LF 1257/CR-LF WinBaltRim windows-1257
CSA_Z243.4-1985-1 ca csa7-1 ISO646-CA iso-ir-121
CSA_Z243.4-1985-2 csa7-2 ISO646-CA2 iso-ir-122
CSA_Z243.4-1985-gr iso-ir-123
CSN_369103 iso-ir-139 koi8l2 KOI-8_L2
CWI cp-hu CWI-2
DEC-MCS dec
DIN_66003 de ISO646-DE iso-ir-21
DS_2089 dk DS2089 ISO646-DK
dump-with-names
EBCDIC
EBCDIC-AT-DE
EBCDIC-AT-DE-A
EBCDIC-CA-FR
EBCDIC-CCC
EBCDIC-DK-NO
EBCDIC-DK-NO-A
EBCDIC-ES
EBCDIC-ES-A
EBCDIC-ES-S
EBCDIC-FI-SE
EBCDIC-FI-SE-A
EBCDIC-FR
EBCDIC-IBM
EBCDIC-IS-FRISS friss
EBCDIC-IT
EBCDIC-PT
EBCDIC-UK
EBCDIC-US
ECMA-cyrillic ECMA-113 ECMA-113:1986 iso-ir-111
ES ISO646-ES iso-ir-17
ES2 ISO646-ES2 iso-ir-85
flat
GB_1988-80 cn ISO646-CN iso-ir-57
GOST_19768-87 iso-ir-153 ST_SEV_358-88
greek7 iso-ir-88
greek7-old iso-ir-18
greek-ccitt iso-ir-150
hp-roman8 r8 roman8
HTML-i18n 2070 RFC2070
HTML_1.1 h1
HTML_2.0 1866 h2 RFC1866
HTML_3.2 h3
HTML_4.0 h h4 HTML
IBM037/CR-LF 037/CR-LF CP037/CR-LF ebcdic-cp-ca ebcdic-cp-nl ebcdic-cp-us ebcdic-cp-wt
IBM038/CR-LF 038/CR-LF CP038/CR-LF EBCDIC-INT
IBM256/CR-LF 256/CR-LF CP256/CR-LF EBCDIC-INT1
IBM273/CR-LF 273/CR-LF CP273/CR-LF
IBM274/CR-LF 274/CR-LF CP274/CR-LF EBCDIC-BE
IBM275/CR-LF 275/CR-LF CP275/CR-LF EBCDIC-BR
IBM277/CR-LF EBCDIC-CP-DK EBCDIC-CP-NO
IBM278/CR-LF 278/CR-LF CP278/CR-LF ebcdic-cp-fi ebcdic-cp-se
IBM280/CR-LF 280/CR-LF CP280/CR-LF ebcdic-cp-it
IBM281/CR-LF 281/CR-LF CP281/CR-LF EBCDIC-JP-E
IBM284/CR-LF 284/CR-LF CP284/CR-LF ebcdic-cp-es
IBM285/CR-LF 285/CR-LF CP285/CR-LF ebcdic-cp-gb
IBM290/CR-LF 290/CR-LF CP290/CR-LF EBCDIC-JP-kana
IBM297/CR-LF 297/CR-LF CP297/CR-LF ebcdic-cp-fr
IBM420/CR-LF 420/CR-LF CP420/CR-LF ebcdic-cp-ar1
IBM423/CR-LF 423/CR-LF CP423/CR-LF ebcdic-cp-gr
IBM424/CR-LF 424/CR-LF CP424/CR-LF ebcdic-cp-he
IBM437/CR-LF 437/CR-LF CP437/CR-LF
IBM500/CR-LF 500/CR-LF 500V1 CP500/CR-LF ebcdic-cp-be ebcdic-cp-ch
IBM850/CR-LF 850/CR-LF CP850/CR-LF
IBM851/CR-LF 851/CR-LF CP851/CR-LF
IBM852/CR-LF 852/CR-LF CP852/CR-LF pcl2 pclatin2
IBM855/CR-LF 855/CR-LF CP855/CR-LF
IBM857/CR-LF 857/CR-LF CP857/CR-LF
IBM860/CR-LF 860/CR-LF CP860/CR-LF
IBM861/CR-LF 861/CR-LF CP861/CR-LF cp-is
IBM862/CR-LF 862/CR-LF CP862/CR-LF
IBM863/CR-LF 863/CR-LF CP863/CR-LF
IBM864/CR-LF 864/CR-LF CP864/CR-LF
IBM865/CR-LF 865/CR-LF CP865/CR-LF
IBM868/CR-LF 868/CR-LF CP868/CR-LF cp-ar
IBM869/CR-LF 869/CR-LF CP869/CR-LF cp-gr
IBM870/CR-LF 870/CR-LF CP870/CR-LF ebcdic-cp-roece ebcdic-cp-yu
IBM871/CR-LF 871/CR-LF CP871/CR-LF ebcdic-cp-is
IBM875/CR-LF 875/CR-LF CP875/CR-LF EBCDIC-Greek
IBM880/CR-LF 880/CR-LF CP880/CR-LF EBCDIC-Cyrillic
IBM891/CR-LF 891/CR-LF CP891/CR-LF
IBM903/CR-LF 903/CR-LF CP903/CR-LF
IBM904/CR-LF 904/CR-LF CP904/CR-LF
IBM905/CR-LF 905/CR-LF CP905/CR-LF ebcdic-cp-tr
IBM918/CR-LF 918/CR-LF CP918/CR-LF ebcdic-cp-ar2
IBM1004/CR-LF 1004/CR-LF CP1004/CR-LF os2latin1
IBM1026/CR-LF 1026/CR-LF CP1026/CR-LF
IBM1047/CR-LF 1047/CR-LF CP1047/CR-LF
IBM-PC/CR-LF dos/CR-LF MSDOS/CR-LF pc/CR-LF
Icon-QNX QNX
IEC_P27-1 iso-ir-143
INIS iso-ir-49
INIS-8 iso-ir-50
INIS-cyrillic iso-ir-51
INVARIANT iso-ir-170
ISO-8859-1 819/CR-LF CP819/CR-LF IBM819/CR-LF iso-ir-100 ISO_8859-1 ISO_8859-1:1987 l1 lat1 latin1 Latin-1
ISO-8859-2 912/CR-LF CP912/CR-LF IBM912/CR-LF iso-ir-101 ISO_8859-2 ISO_8859-2:1987 l2 latin2
ISO-8859-3 iso-ir-109 ISO_8859-3 ISO_8859-3:1988 l3 latin3
ISO-8859-4 iso-ir-110 ISO_8859-4 ISO_8859-4:1988 l4 latin4
ISO-8859-5 cyrillic iso-ir-144 ISO_8859-5 ISO_8859-5:1988
ISO-8859-6 arabic ASMO-708 ECMA-114 iso-ir-127 ISO_8859-6 ISO_8859-6:1987
ISO-8859-7 ECMA-118 ELOT_928 greek greek8 iso-ir-126 ISO_8859-7 ISO_8859-7:1987
ISO-8859-8 hebrew iso-ir-138 ISO_8859-8 ISO_8859-8:1988
ISO-8859-9 iso-ir-148 ISO_8859-9 ISO_8859-9:1989 l5 latin5
ISO-8859-10 iso-ir-157 ISO_8859-10 ISO_8859-10:1993 l6 latin6
ISO-8859-13 iso-baltic iso-ir-179a ISO_8859-13 ISO_8859-13:1998 l7 latin7
ISO-8859-14 iso-celtic iso-ir-199 ISO_8859-14 ISO_8859-14:1998 l8 latin8
ISO-8859-15 iso-ir-203 ISO_8859-15 ISO_8859-15:1998 l9 latin9
ISO-10646-UCS-2 BMP rune u2 UCS-2 UNICODE-1-1
ISO-10646-UCS-4 10646 ISO_10646 u4 UCS UCS-4
ISO_646.basic ISO_646.basic:1983 ref
ISO_646.irv irv iso-ir-2 ISO_646.irv:1983
ISO_2033-1983 e13b iso-ir-98
ISO_5427 iso-ir-37
ISO_5427-ext iso-ir-54 ISO_5427:1981
ISO_5428 iso-ir-55 ISO_5428:1980
ISO_6937-2-25 iso-ir-152
ISO_8859-supp iso-ir-154 latin1-2-5
ISO_10367-box iso-ir-155
IT ISO646-IT iso-ir-15
JIS_C6220-1969-jp iso-ir-13 JIS_C6220-1969 katakana x0201-7
JIS_C6220-1969-ro ISO646-JP iso-ir-14 jp
JIS_C6229-1984-a jp-ocr-a
JIS_C6229-1984-b ISO646-JP-OCR-B jp-ocr-b
JIS_C6229-1984-b-add iso-ir-93 jp-ocr-b-add
JIS_C6229-1984-hand iso-ir-94 jp-ocr-hand
JIS_C6229-1984-hand-add iso-ir-95 jp-ocr-hand-add
JIS_C6229-1984-kana iso-ir-96
JIS_X0201 X0201
JUS_I.B1.002 ISO646-YU iso-ir-141 js yu
JUS_I.B1.003-mac iso-ir-147 macedonian
JUS_I.B1.003-serb iso-ir-146 serbian
KEYBCS2 Kamenicky
KOI8-R
KOI8-RU
KOI8-U
KOI-7
KOI-8 GOST_19768-74
KOI-8_CS2
KSC5636 ISO646-KR
LaTeX ltex TeX
latin-greek iso-ir-19
Latin-greek-1 iso-ir-27
mac-is
macintosh/CR mac/CR
macintosh_ce/CR macce/CR
MSZ_7795.3 hu ISO646-HU iso-ir-86
Mule
NATS-DANO iso-ir-9-1
NATS-DANO-ADD iso-ir-9-2
NATS-SEFI iso-ir-8-1
NATS-SEFI-ADD iso-ir-8-2
NC_NC00-10 cuba ISO646-CU iso-ir-151 NC_NC00-10:81
NeXTSTEP next
NF_Z_62-010 fr ISO646-FR iso-ir-69
NF_Z_62-010_(1973) ISO646-FR1 iso-ir-25
NS_4551-1 ISO646-NO iso-ir-60 no
NS_4551-2 ISO646-NO2 iso-ir-61 no2
PT ISO646-PT iso-ir-16
PT2 ISO646-PT2 iso-ir-84
RFC1345 1345 mnemonic
sami iso-ir-158 lap latin-lap
SEN_850200_B FI ISO646-FI ISO646-SE iso-ir-10 se SS636127
SEN_850200_C ISO646-SE2 iso-ir-11 se2
T.61-7bit iso-ir-102
Texinfo texi ti
Texte txte
UNICODE-1-1-UTF-7 TF-7 u7 UTF-7
UTF-8 FSS_UTF TF-8 u8 UTF-2 UTF-FSS
UTF-16 TF-16 u6 Unicode
EOF

test -n "$at_verbose" \
  && echo $srcdir'/names.m4:224: Testing list of charsets and surfaces'
echo names.m4:224 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode -l
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s1)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 1"
       ;;
  esac
  at_test_count=1
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr expout
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c2(

rm -rf stdout stderr expout
# Snippet )c2)
  echo names.m4:228 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing the --find-subsets option'
    echo $at_n "     $at_c"
  fi
  echo $at_n "2. $srcdir/names.m4:228       $at_c"
  (
# Snippet (s2(

# The test group starts at `names.m4:228'.  An error occurred while
# testing the --find-subsets option.

cat >expout <<'EOF'
[  0] ANSI_X3.4-1968 == IBM891
[  0] ANSI_X3.4-1968 == IBM903
[  0] IBM891 == ANSI_X3.4-1968
[  0] IBM891 == IBM903
[  0] IBM903 == ANSI_X3.4-1968
[  0] IBM903 == IBM891
[  3] ANSI_X3.4-1968 < IBM904
[  3] IBM891 < IBM904
[  3] IBM903 < IBM904
[  3] JIS_C6229-1984-hand-add < JIS_C6229-1984-b-add
[  4] IBM1004 < CP1252
[  6] INVARIANT < T.61-7bit
[  6] T.61-7bit < ISO_646.irv
[ 10] INVARIANT < JIS_C6229-1984-b
[ 12] INVARIANT < ANSI_X3.4-1968
[ 12] INVARIANT < BS_4730
[ 12] INVARIANT < CSA_Z243.4-1985-1
[ 12] INVARIANT < CSA_Z243.4-1985-2
[ 12] INVARIANT < DIN_66003
[ 12] INVARIANT < DS_2089
[ 12] INVARIANT < ES
[ 12] INVARIANT < ES2
[ 12] INVARIANT < GB_1988-80
[ 12] INVARIANT < IBM891
[ 12] INVARIANT < IBM903
[ 12] INVARIANT < ISO_646.irv
[ 12] INVARIANT < IT
[ 12] INVARIANT < JIS_C6220-1969-ro
[ 12] INVARIANT < JUS_I.B1.002
[ 12] INVARIANT < KSC5636
[ 12] INVARIANT < MSZ_7795.3
[ 12] INVARIANT < NATS-SEFI
[ 12] INVARIANT < NC_NC00-10
[ 12] INVARIANT < NF_Z_62-010
[ 12] INVARIANT < NF_Z_62-010_(1973)
[ 12] INVARIANT < NS_4551-1
[ 12] INVARIANT < NS_4551-2
[ 12] INVARIANT < PT
[ 12] INVARIANT < PT2
[ 12] INVARIANT < SEN_850200_B
[ 12] INVARIANT < SEN_850200_C
[ 12] JIS_C6229-1984-kana < JIS_C6220-1969-jp
[ 13] INIS < ANSI_X3.4-1968
[ 13] INIS < BS_4730
[ 13] INIS < IBM891
[ 13] INIS < IBM903
[ 13] INIS < JIS_C6220-1969-ro
[ 13] INIS < KSC5636
[ 15] INVARIANT < IBM904
[ 16] INIS < IBM904
[ 28] GOST_19768-87 < ISO-8859-5
[ 28] JIS_C6229-1984-hand < JIS_C6229-1984-b
[ 33] ISO_646.basic < INVARIANT
[ 39] ISO_646.basic < T.61-7bit
[ 43] ISO_646.basic < JIS_C6229-1984-b
[ 45] ISO_646.basic < ANSI_X3.4-1968
[ 45] ISO_646.basic < BS_4730
[ 45] ISO_646.basic < CSA_Z243.4-1985-1
[ 45] ISO_646.basic < CSA_Z243.4-1985-2
[ 45] ISO_646.basic < DIN_66003
[ 45] ISO_646.basic < DS_2089
[ 45] ISO_646.basic < ES
[ 45] ISO_646.basic < ES2
[ 45] ISO_646.basic < GB_1988-80
[ 45] ISO_646.basic < IBM891
[ 45] ISO_646.basic < IBM903
[ 45] ISO_646.basic < ISO_646.irv
[ 45] ISO_646.basic < IT
[ 45] ISO_646.basic < JIS_C6220-1969-ro
[ 45] ISO_646.basic < JUS_I.B1.002
[ 45] ISO_646.basic < KSC5636
[ 45] ISO_646.basic < MSZ_7795.3
[ 45] ISO_646.basic < NATS-SEFI
[ 45] ISO_646.basic < NC_NC00-10
[ 45] ISO_646.basic < NF_Z_62-010
[ 45] ISO_646.basic < NF_Z_62-010_(1973)
[ 45] ISO_646.basic < NS_4551-1
[ 45] ISO_646.basic < NS_4551-2
[ 45] ISO_646.basic < PT
[ 45] ISO_646.basic < PT2
[ 45] ISO_646.basic < SEN_850200_B
[ 45] ISO_646.basic < SEN_850200_C
[ 48] ISO_646.basic < IBM904
[ 57] EBCDIC-US < IBM424
[ 61] ANSI_X3.4-1968 < ISO_10367-box
[ 61] IBM891 < ISO_10367-box
[ 61] IBM903 < ISO_10367-box
[ 63] ANSI_X3.4-1968 < KOI-8
[ 63] IBM891 < KOI-8
[ 63] IBM903 < KOI-8
[ 64] T.61-7bit < ISO_6937-2-25
[ 65] KOI-8 < ECMA-cyrillic
[ 65] KOI-8 < KOI8-R
[ 65] KOI-8 < KOI8-RU
[ 66] ANSI_X3.4-1968 < sami
[ 66] IBM891 < sami
[ 66] IBM903 < sami
[ 70] INVARIANT < ISO_6937-2-25
[ 73] INVARIANT < ISO_10367-box
[ 74] INIS < ISO_10367-box
[ 75] INVARIANT < KOI-8
[ 76] INIS < KOI-8
[ 78] ANSI_X3.4-1968 < CP1255
[ 78] IBM891 < CP1255
[ 78] IBM903 < CP1255
[ 78] INVARIANT < sami
[ 79] INIS < sami
[ 83] ANSI_X3.4-1968 < ISO-8859-6
[ 83] IBM891 < ISO-8859-6
[ 83] IBM903 < ISO-8859-6
[ 90] ANSI_X3.4-1968 < ISO-8859-8
[ 90] IBM891 < ISO-8859-8
[ 90] IBM903 < ISO-8859-8
[ 90] INVARIANT < CP1255
[ 91] INIS < CP1255
[ 95] INVARIANT < ISO-8859-6
[ 95] JIS_C6220-1969-ro < JIS_X0201
[ 96] EBCDIC-AT-DE < IBM273
[ 96] EBCDIC-DK-NO < IBM277
[ 96] EBCDIC-IT < IBM280
[ 96] EBCDIC-UK < IBM285
[ 96] EBCDIC-US < IBM037
[ 96] IBM038 < IBM256
[ 96] IBM038 < IBM500
[ 96] INIS < ISO-8859-6
[100] ANSI_X3.4-1968 < GOST_19768-87
[100] IBM891 < GOST_19768-87
[100] IBM903 < GOST_19768-87
[102] INVARIANT < ISO-8859-8
[103] ANSI_X3.4-1968 < IBM868
[103] IBM891 < IBM868
[103] IBM903 < IBM868
[103] INIS < ISO-8859-8
[103] ISO_646.basic < ISO_6937-2-25
[106] ISO_646.basic < ISO_10367-box
[107] INVARIANT < JIS_X0201
[108] INIS < JIS_X0201
[108] ISO_646.basic < KOI-8
[109] ANSI_X3.4-1968 < CP1257
[109] IBM891 < CP1257
[109] IBM903 < CP1257
[111] ANSI_X3.4-1968 < CP1253
[111] IBM891 < CP1253
[111] IBM903 < CP1253
[111] ISO_646.basic < sami
[112] ANSI_X3.4-1968 < KOI8-U
[112] IBM891 < KOI8-U
[112] IBM903 < KOI8-U
[112] INVARIANT < GOST_19768-87
[113] ANSI_X3.4-1968 < DEC-MCS
[113] IBM891 < DEC-MCS
[113] IBM903 < DEC-MCS
[113] INIS < GOST_19768-87
[115] INVARIANT < IBM868
[116] INIS < IBM868
[119] ANSI_X3.4-1968 < IBM1004
[119] ANSI_X3.4-1968 < IBM869
[119] IBM891 < IBM1004
[119] IBM891 < IBM869
[119] IBM903 < IBM1004
[119] IBM903 < IBM869
[121] ANSI_X3.4-1968 < CP1254
[121] ANSI_X3.4-1968 < ISO-8859-3
[121] ANSI_X3.4-1968 < NeXTSTEP
[121] IBM891 < CP1254
[121] IBM891 < ISO-8859-3
[121] IBM891 < NeXTSTEP
[121] IBM903 < CP1254
[121] IBM903 < ISO-8859-3
[121] IBM903 < NeXTSTEP
[121] INVARIANT < CP1257
[122] ANSI_X3.4-1968 < ISO-8859-7
[122] ANSI_X3.4-1968 < ISO_8859-supp
[122] IBM891 < ISO-8859-7
[122] IBM891 < ISO_8859-supp
[122] IBM903 < ISO-8859-7
[122] IBM903 < ISO_8859-supp
[122] INIS < CP1257
[123] ANSI_X3.4-1968 < CP1250
[123] ANSI_X3.4-1968 < CP1252
[123] ANSI_X3.4-1968 < IBM864
[123] IBM891 < CP1250
[123] IBM891 < CP1252
[123] IBM891 < IBM864
[123] IBM903 < CP1250
[123] IBM903 < CP1252
[123] IBM903 < IBM864
[123] INVARIANT < CP1253
[123] ISO_646.basic < CP1255
[124] INIS < CP1253
[124] INVARIANT < KOI8-U
[125] ANSI_X3.4-1968 < IBM857
[125] IBM891 < IBM857
[125] IBM903 < IBM857
[125] INIS < KOI8-U
[125] INVARIANT < DEC-MCS
[126] ANSI_X3.4-1968 < CP1256
[126] ANSI_X3.4-1968 < mac-is
[126] ANSI_X3.4-1968 < macintosh
[126] IBM891 < CP1256
[126] IBM891 < mac-is
[126] IBM891 < macintosh
[126] IBM903 < CP1256
[126] IBM903 < mac-is
[126] IBM903 < macintosh
[126] INIS < DEC-MCS
[127] ANSI_X3.4-1968 < CP1251
[127] ANSI_X3.4-1968 < IBM851
[127] ANSI_X3.4-1968 < IBM855
[127] ANSI_X3.4-1968 < IBM861
[127] ANSI_X3.4-1968 < IBM862
[127] ANSI_X3.4-1968 < hp-roman8
[127] IBM891 < CP1251
[127] IBM891 < IBM851
[127] IBM891 < IBM855
[127] IBM891 < IBM861
[127] IBM891 < IBM862
[127] IBM891 < hp-roman8
[127] IBM903 < CP1251
[127] IBM903 < IBM851
[127] IBM903 < IBM855
[127] IBM903 < IBM861
[127] IBM903 < IBM862
[127] IBM903 < hp-roman8
[128] ANSI_X3.4-1968 < AtariST
[128] ANSI_X3.4-1968 < CSA_Z243.4-1985-gr
[128] ANSI_X3.4-1968 < CWI
[128] ANSI_X3.4-1968 < ECMA-cyrillic
[128] ANSI_X3.4-1968 < IBM437
[128] ANSI_X3.4-1968 < IBM850
[128] ANSI_X3.4-1968 < IBM852
[128] ANSI_X3.4-1968 < IBM860
[128] ANSI_X3.4-1968 < IBM863
[128] ANSI_X3.4-1968 < IBM865
[128] ANSI_X3.4-1968 < IEC_P27-1
[128] ANSI_X3.4-1968 < ISO-8859-1
[128] ANSI_X3.4-1968 < ISO-8859-10
[128] ANSI_X3.4-1968 < ISO-8859-13
[128] ANSI_X3.4-1968 < ISO-8859-14
[128] ANSI_X3.4-1968 < ISO-8859-15
[128] ANSI_X3.4-1968 < ISO-8859-2
[128] ANSI_X3.4-1968 < ISO-8859-4
[128] ANSI_X3.4-1968 < ISO-8859-5
[128] ANSI_X3.4-1968 < ISO-8859-9
[128] ANSI_X3.4-1968 < KOI8-R
[128] ANSI_X3.4-1968 < KOI8-RU
[128] ANSI_X3.4-1968 < baltic
[128] ANSI_X3.4-1968 < macintosh_ce
[128] IBM891 < AtariST
[128] IBM891 < CSA_Z243.4-1985-gr
[128] IBM891 < CWI
[128] IBM891 < ECMA-cyrillic
[128] IBM891 < IBM437
[128] IBM891 < IBM850
[128] IBM891 < IBM852
[128] IBM891 < IBM860
[128] IBM891 < IBM863
[128] IBM891 < IBM865
[128] IBM891 < IEC_P27-1
[128] IBM891 < ISO-8859-1
[128] IBM891 < ISO-8859-10
[128] IBM891 < ISO-8859-13
[128] IBM891 < ISO-8859-14
[128] IBM891 < ISO-8859-15
[128] IBM891 < ISO-8859-2
[128] IBM891 < ISO-8859-4
[128] IBM891 < ISO-8859-5
[128] IBM891 < ISO-8859-9
[128] IBM891 < KOI8-R
[128] IBM891 < KOI8-RU
[128] IBM891 < baltic
[128] IBM891 < macintosh_ce
[128] IBM903 < AtariST
[128] IBM903 < CSA_Z243.4-1985-gr
[128] IBM903 < CWI
[128] IBM903 < ECMA-cyrillic
[128] IBM903 < IBM437
[128] IBM903 < IBM850
[128] IBM903 < IBM852
[128] IBM903 < IBM860
[128] IBM903 < IBM863
[128] IBM903 < IBM865
[128] IBM903 < IEC_P27-1
[128] IBM903 < ISO-8859-1
[128] IBM903 < ISO-8859-10
[128] IBM903 < ISO-8859-13
[128] IBM903 < ISO-8859-14
[128] IBM903 < ISO-8859-15
[128] IBM903 < ISO-8859-2
[128] IBM903 < ISO-8859-4
[128] IBM903 < ISO-8859-5
[128] IBM903 < ISO-8859-9
[128] IBM903 < KOI8-R
[128] IBM903 < KOI8-RU
[128] IBM903 < baltic
[128] IBM903 < macintosh_ce
[128] ISO_646.basic < ISO-8859-6
[131] INVARIANT < IBM1004
[131] INVARIANT < IBM869
[132] INIS < IBM1004
[132] INIS < IBM869
[133] INVARIANT < CP1254
[133] INVARIANT < ISO-8859-3
[133] INVARIANT < NeXTSTEP
[134] INIS < CP1254
[134] INIS < ISO-8859-3
[134] INIS < NeXTSTEP
[134] INVARIANT < ISO-8859-7
[134] INVARIANT < ISO_8859-supp
[134] T.61-7bit < CSN_369103
[135] INIS < ISO-8859-7
[135] INIS < ISO_8859-supp
[135] INVARIANT < CP1250
[135] INVARIANT < CP1252
[135] INVARIANT < IBM864
[135] ISO_646.basic < ISO-8859-8
[136] INIS < CP1250
[136] INIS < CP1252
[136] INIS < IBM864
[137] INVARIANT < IBM857
[138] INIS < IBM857
[138] INVARIANT < CP1256
[138] INVARIANT < mac-is
[138] INVARIANT < macintosh
[139] INIS < CP1256
[139] INIS < mac-is
[139] INIS < macintosh
[139] INVARIANT < CP1251
[139] INVARIANT < IBM851
[139] INVARIANT < IBM855
[139] INVARIANT < IBM861
[139] INVARIANT < IBM862
[139] INVARIANT < hp-roman8
[140] INIS < CP1251
[140] INIS < IBM851
[140] INIS < IBM855
[140] INIS < IBM861
[140] INIS < IBM862
[140] INIS < hp-roman8
[140] INVARIANT < AtariST
[140] INVARIANT < CSA_Z243.4-1985-gr
[140] INVARIANT < CSN_369103
[140] INVARIANT < CWI
[140] INVARIANT < ECMA-cyrillic
[140] INVARIANT < IBM437
[140] INVARIANT < IBM850
[140] INVARIANT < IBM852
[140] INVARIANT < IBM860
[140] INVARIANT < IBM863
[140] INVARIANT < IBM865
[140] INVARIANT < IEC_P27-1
[140] INVARIANT < ISO-8859-1
[140] INVARIANT < ISO-8859-10
[140] INVARIANT < ISO-8859-13
[140] INVARIANT < ISO-8859-14
[140] INVARIANT < ISO-8859-15
[140] INVARIANT < ISO-8859-2
[140] INVARIANT < ISO-8859-4
[140] INVARIANT < ISO-8859-5
[140] INVARIANT < ISO-8859-9
[140] INVARIANT < KOI8-R
[140] INVARIANT < KOI8-RU
[140] INVARIANT < baltic
[140] INVARIANT < macintosh_ce
[140] ISO_646.basic < JIS_X0201
[141] INIS < AtariST
[141] INIS < CSA_Z243.4-1985-gr
[141] INIS < CWI
[141] INIS < ECMA-cyrillic
[141] INIS < IBM437
[141] INIS < IBM850
[141] INIS < IBM852
[141] INIS < IBM860
[141] INIS < IBM863
[141] INIS < IBM865
[141] INIS < IEC_P27-1
[141] INIS < ISO-8859-1
[141] INIS < ISO-8859-10
[141] INIS < ISO-8859-13
[141] INIS < ISO-8859-14
[141] INIS < ISO-8859-15
[141] INIS < ISO-8859-2
[141] INIS < ISO-8859-4
[141] INIS < ISO-8859-5
[141] INIS < ISO-8859-9
[141] INIS < KOI8-R
[141] INIS < KOI8-RU
[141] INIS < baltic
[141] INIS < macintosh_ce
[145] ISO_646.basic < GOST_19768-87
[148] ISO_646.basic < IBM868
[154] ISO_646.basic < CP1257
[156] ISO_646.basic < CP1253
[157] ISO_646.basic < KOI8-U
[158] ISO_646.basic < DEC-MCS
[164] ISO_646.basic < IBM1004
[164] ISO_646.basic < IBM869
[166] ISO_646.basic < CP1254
[166] ISO_646.basic < ISO-8859-3
[166] ISO_646.basic < NeXTSTEP
[167] ISO_646.basic < ISO-8859-7
[167] ISO_646.basic < ISO_8859-supp
[168] ISO_646.basic < CP1250
[168] ISO_646.basic < CP1252
[168] ISO_646.basic < IBM864
[170] ISO_646.basic < IBM857
[171] ISO_646.basic < CP1256
[171] ISO_646.basic < mac-is
[171] ISO_646.basic < macintosh
[172] ISO_646.basic < CP1251
[172] ISO_646.basic < IBM851
[172] ISO_646.basic < IBM855
[172] ISO_646.basic < IBM861
[172] ISO_646.basic < IBM862
[172] ISO_646.basic < hp-roman8
[173] ISO_646.basic < AtariST
[173] ISO_646.basic < CSA_Z243.4-1985-gr
[173] ISO_646.basic < CSN_369103
[173] ISO_646.basic < CWI
[173] ISO_646.basic < ECMA-cyrillic
[173] ISO_646.basic < IBM437
[173] ISO_646.basic < IBM850
[173] ISO_646.basic < IBM852
[173] ISO_646.basic < IBM860
[173] ISO_646.basic < IBM863
[173] ISO_646.basic < IBM865
[173] ISO_646.basic < IEC_P27-1
[173] ISO_646.basic < ISO-8859-1
[173] ISO_646.basic < ISO-8859-10
[173] ISO_646.basic < ISO-8859-13
[173] ISO_646.basic < ISO-8859-14
[173] ISO_646.basic < ISO-8859-15
[173] ISO_646.basic < ISO-8859-2
[173] ISO_646.basic < ISO-8859-4
[173] ISO_646.basic < ISO-8859-5
[173] ISO_646.basic < ISO-8859-9
[173] ISO_646.basic < KOI8-R
[173] ISO_646.basic < KOI8-RU
[173] ISO_646.basic < baltic
[173] ISO_646.basic < macintosh_ce
EOF

test -n "$at_verbose" \
  && echo $srcdir'/names.m4:676: Testing the --find-subsets option'
echo names.m4:676 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode -T | sort
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s2)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 2"
       ;;
  esac
  at_test_count=2
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr expout
  fi
fi

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c3(

rm -rf expect stdout stderr
# Snippet )c3)
  echo lists.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing decimal listing of a charset'
    echo $at_n "     $at_c"
  fi
  echo $at_n "3. $srcdir/lists.m4:3         $at_c"
  (
# Snippet (s3(

# The test group starts at `lists.m4:3'.  An error occurred while
# testing decimal listing of a charset.

cat > expect <<'EOF'
ISO-8859-1

  0 NU    16 DL    32 SP    48 0     64 @     80 P     96 '!   112 p
  1 SH    17 D1    33 !     49 1     65 A     81 Q     97 a    113 q
  2 SX    18 D2    34 "     50 2     66 B     82 R     98 b    114 r
  3 EX    19 D3    35 Nb    51 3     67 C     83 S     99 c    115 s
  4 ET    20 D4    36 DO    52 4     68 D     84 T    100 d    116 t
  5 EQ    21 NK    37 %     53 5     69 E     85 U    101 e    117 u
  6 AK    22 SY    38 &     54 6     70 F     86 V    102 f    118 v
  7 BL    23 EB    39 '     55 7     71 G     87 W    103 g    119 w
  8 BS    24 CN    40 (     56 8     72 H     88 X    104 h    120 x
  9 HT    25 EM    41 )     57 9     73 I     89 Y    105 i    121 y
 10 LF    26 SB    42 *     58 :     74 J     90 Z    106 j    122 z
 11 VT    27 EC    43 +     59 ;     75 K     91 <(   107 k    123 (!
 12 FF    28 FS    44 ,     60 <     76 L     92 //   108 l    124 !!
 13 CR    29 GS    45 -     61 =     77 M     93 )>   109 m    125 !)
 14 SO    30 RS    46 .     62 >     78 N     94 '>   110 n    126 '?
 15 SI    31 US    47 /     63 ?     79 O     95 _    111 o    127 DT

128 PA   144 DC   160 NS   176 DG   192 A!   208 D-   224 a!   240 d-
129 HO   145 P1   161 !I   177 +-   193 A'   209 N?   225 a'   241 n?
130 BH   146 P2   162 Ct   178 2S   194 A>   210 O!   226 a>   242 o!
131 NH   147 TS   163 Pd   179 3S   195 A?   211 O'   227 a?   243 o'
132 IN   148 CC   164 Cu   180 ''   196 A:   212 O>   228 a:   244 o>
133 NL   149 MW   165 Ye   181 My   197 AA   213 O?   229 aa   245 o?
134 SA   150 SG   166 BB   182 PI   198 AE   214 O:   230 ae   246 o:
135 ES   151 EG   167 SE   183 .M   199 C,   215 *X   231 c,   247 -:
136 HS   152 SS   168 ':   184 ',   200 E!   216 O/   232 e!   248 o/
137 HJ   153 GC   169 Co   185 1S   201 E'   217 U!   233 e'   249 u!
138 VS   154 SC   170 -a   186 -o   202 E>   218 U'   234 e>   250 u'
139 PD   155 CI   171 <<   187 >>   203 E:   219 U>   235 e:   251 u>
140 PU   156 ST   172 NO   188 14   204 I!   220 U:   236 i!   252 u:
141 RI   157 OC   173 --   189 12   205 I'   221 Y'   237 i'   253 y'
142 S2   158 PM   174 Rg   190 34   206 I>   222 TH   238 i>   254 th
143 S3   159 AC   175 'm   191 ?I   207 I:   223 ss   239 i:   255 y:
EOF

test -n "$at_verbose" \
  && echo $srcdir'/lists.m4:44: Testing decimal listing of a charset'
echo lists.m4:44 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode -ld latin-1 | cmp -s - expect
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s3)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 3"
       ;;
  esac
  at_test_count=3
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expect stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c4(

rm -rf expect stdout stderr
# Snippet )c4)
  echo lists.m4:48 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing hexadecimal listing of a charset'
    echo $at_n "     $at_c"
  fi
  echo $at_n "4. $srcdir/lists.m4:48        $at_c"
  (
# Snippet (s4(

# The test group starts at `lists.m4:48'.  An error occurred while
# testing hexadecimal listing of a charset.

cat > expect <<'EOF'
ISO-8859-1

00 NU   10 DL   20 SP   30 0    40 @    50 P    60 '!   70 p
01 SH   11 D1   21 !    31 1    41 A    51 Q    61 a    71 q
02 SX   12 D2   22 "    32 2    42 B    52 R    62 b    72 r
03 EX   13 D3   23 Nb   33 3    43 C    53 S    63 c    73 s
04 ET   14 D4   24 DO   34 4    44 D    54 T    64 d    74 t
05 EQ   15 NK   25 %    35 5    45 E    55 U    65 e    75 u
06 AK   16 SY   26 &    36 6    46 F    56 V    66 f    76 v
07 BL   17 EB   27 '    37 7    47 G    57 W    67 g    77 w
08 BS   18 CN   28 (    38 8    48 H    58 X    68 h    78 x
09 HT   19 EM   29 )    39 9    49 I    59 Y    69 i    79 y
0a LF   1a SB   2a *    3a :    4a J    5a Z    6a j    7a z
0b VT   1b EC   2b +    3b ;    4b K    5b <(   6b k    7b (!
0c FF   1c FS   2c ,    3c <    4c L    5c //   6c l    7c !!
0d CR   1d GS   2d -    3d =    4d M    5d )>   6d m    7d !)
0e SO   1e RS   2e .    3e >    4e N    5e '>   6e n    7e '?
0f SI   1f US   2f /    3f ?    4f O    5f _    6f o    7f DT

80 PA   90 DC   a0 NS   b0 DG   c0 A!   d0 D-   e0 a!   f0 d-
81 HO   91 P1   a1 !I   b1 +-   c1 A'   d1 N?   e1 a'   f1 n?
82 BH   92 P2   a2 Ct   b2 2S   c2 A>   d2 O!   e2 a>   f2 o!
83 NH   93 TS   a3 Pd   b3 3S   c3 A?   d3 O'   e3 a?   f3 o'
84 IN   94 CC   a4 Cu   b4 ''   c4 A:   d4 O>   e4 a:   f4 o>
85 NL   95 MW   a5 Ye   b5 My   c5 AA   d5 O?   e5 aa   f5 o?
86 SA   96 SG   a6 BB   b6 PI   c6 AE   d6 O:   e6 ae   f6 o:
87 ES   97 EG   a7 SE   b7 .M   c7 C,   d7 *X   e7 c,   f7 -:
88 HS   98 SS   a8 ':   b8 ',   c8 E!   d8 O/   e8 e!   f8 o/
89 HJ   99 GC   a9 Co   b9 1S   c9 E'   d9 U!   e9 e'   f9 u!
8a VS   9a SC   aa -a   ba -o   ca E>   da U'   ea e>   fa u'
8b PD   9b CI   ab <<   bb >>   cb E:   db U>   eb e:   fb u>
8c PU   9c ST   ac NO   bc 14   cc I!   dc U:   ec i!   fc u:
8d RI   9d OC   ad --   bd 12   cd I'   dd Y'   ed i'   fd y'
8e S2   9e PM   ae Rg   be 34   ce I>   de TH   ee i>   fe th
8f S3   9f AC   af 'm   bf ?I   cf I:   df ss   ef i:   ff y:
EOF

test -n "$at_verbose" \
  && echo $srcdir'/lists.m4:89: Testing hexadecimal listing of a charset'
echo lists.m4:89 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode -lh latin-1 | cmp -s - expect
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s4)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 4"
       ;;
  esac
  at_test_count=4
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expect stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c5(

rm -rf expect stdout stderr
# Snippet )c5)
  echo lists.m4:93 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing octal listing of a charset'
    echo $at_n "     $at_c"
  fi
  echo $at_n "5. $srcdir/lists.m4:93        $at_c"
  (
# Snippet (s5(

# The test group starts at `lists.m4:93'.  An error occurred while
# testing octal listing of a charset.

cat > expect <<'EOF'
ISO-8859-1

000 NU   020 DL   040 SP   060 0    100 @    120 P    140 '!   160 p
001 SH   021 D1   041 !    061 1    101 A    121 Q    141 a    161 q
002 SX   022 D2   042 "    062 2    102 B    122 R    142 b    162 r
003 EX   023 D3   043 Nb   063 3    103 C    123 S    143 c    163 s
004 ET   024 D4   044 DO   064 4    104 D    124 T    144 d    164 t
005 EQ   025 NK   045 %    065 5    105 E    125 U    145 e    165 u
006 AK   026 SY   046 &    066 6    106 F    126 V    146 f    166 v
007 BL   027 EB   047 '    067 7    107 G    127 W    147 g    167 w
010 BS   030 CN   050 (    070 8    110 H    130 X    150 h    170 x
011 HT   031 EM   051 )    071 9    111 I    131 Y    151 i    171 y
012 LF   032 SB   052 *    072 :    112 J    132 Z    152 j    172 z
013 VT   033 EC   053 +    073 ;    113 K    133 <(   153 k    173 (!
014 FF   034 FS   054 ,    074 <    114 L    134 //   154 l    174 !!
015 CR   035 GS   055 -    075 =    115 M    135 )>   155 m    175 !)
016 SO   036 RS   056 .    076 >    116 N    136 '>   156 n    176 '?
017 SI   037 US   057 /    077 ?    117 O    137 _    157 o    177 DT

200 PA   220 DC   240 NS   260 DG   300 A!   320 D-   340 a!   360 d-
201 HO   221 P1   241 !I   261 +-   301 A'   321 N?   341 a'   361 n?
202 BH   222 P2   242 Ct   262 2S   302 A>   322 O!   342 a>   362 o!
203 NH   223 TS   243 Pd   263 3S   303 A?   323 O'   343 a?   363 o'
204 IN   224 CC   244 Cu   264 ''   304 A:   324 O>   344 a:   364 o>
205 NL   225 MW   245 Ye   265 My   305 AA   325 O?   345 aa   365 o?
206 SA   226 SG   246 BB   266 PI   306 AE   326 O:   346 ae   366 o:
207 ES   227 EG   247 SE   267 .M   307 C,   327 *X   347 c,   367 -:
210 HS   230 SS   250 ':   270 ',   310 E!   330 O/   350 e!   370 o/
211 HJ   231 GC   251 Co   271 1S   311 E'   331 U!   351 e'   371 u!
212 VS   232 SC   252 -a   272 -o   312 E>   332 U'   352 e>   372 u'
213 PD   233 CI   253 <<   273 >>   313 E:   333 U>   353 e:   373 u>
214 PU   234 ST   254 NO   274 14   314 I!   334 U:   354 i!   374 u:
215 RI   235 OC   255 --   275 12   315 I'   335 Y'   355 i'   375 y'
216 S2   236 PM   256 Rg   276 34   316 I>   336 TH   356 i>   376 th
217 S3   237 AC   257 'm   277 ?I   317 I:   337 ss   357 i:   377 y:
EOF

test -n "$at_verbose" \
  && echo $srcdir'/lists.m4:134: Testing octal listing of a charset'
echo lists.m4:134 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode -lo latin-1 | cmp -s - expect
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s5)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 5"
       ;;
  esac
  at_test_count=5
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expect stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c6(

rm -rf expect stdout stderr
# Snippet )c6)
  echo lists.m4:138 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing full listing of a charset'
    echo $at_n "     $at_c"
  fi
  echo $at_n "6. $srcdir/lists.m4:138       $at_c"
  (
# Snippet (s6(

# The test group starts at `lists.m4:138'.  An error occurred while
# testing full listing of a charset.

cat > expect <<'EOF'
Dec  Oct Hex   UCS2  Mne  ISO-8859-1

  0  000  00   0000  NU   null (nul)
  1  001  01   0001  SH   start of heading (soh)
  2  002  02   0002  SX   start of text (stx)
  3  003  03   0003  EX   end of text (etx)
  4  004  04   0004  ET   end of transmission (eot)
  5  005  05   0005  EQ   enquiry (enq)
  6  006  06   0006  AK   acknowledge (ack)
  7  007  07   0007  BL   bell (bel)
  8  010  08   0008  BS   backspace (bs)
  9  011  09   0009  HT   character tabulation (ht)
 10  012  0a   000A  LF   line feed (lf)
 11  013  0b   000B  VT   line tabulation (vt)
 12  014  0c   000C  FF   form feed (ff)
 13  015  0d   000D  CR   carriage return (cr)
 14  016  0e   000E  SO   shift out (so)
 15  017  0f   000F  SI   shift in (si)
 16  020  10   0010  DL   datalink escape (dle)
 17  021  11   0011  D1   device control one (dc1)
 18  022  12   0012  D2   device control two (dc2)
 19  023  13   0013  D3   device control three (dc3)
 20  024  14   0014  D4   device control four (dc4)
 21  025  15   0015  NK   negative acknowledge (nak)
 22  026  16   0016  SY   syncronous idle (syn)
 23  027  17   0017  EB   end of transmission block (etb)
 24  030  18   0018  CN   cancel (can)
 25  031  19   0019  EM   end of medium (em)
 26  032  1a   001A  SB   substitute (sub)
 27  033  1b   001B  EC   escape (esc)
 28  034  1c   001C  FS   file separator (is4)
 29  035  1d   001D  GS   group separator (is3)
 30  036  1e   001E  RS   record separator (is2)
 31  037  1f   001F  US   unit separator (is1)
 32  040  20   0020  SP   space
 33  041  21   0021  !    exclamation mark
 34  042  22   0022  "    quotation mark
 35  043  23   0023  Nb   number sign
 36  044  24   0024  DO   dollar sign
 37  045  25   0025  %    percent sign
 38  046  26   0026  &    ampersand
 39  047  27   0027  '    apostrophe
 40  050  28   0028  (    left parenthesis
 41  051  29   0029  )    right parenthesis
 42  052  2a   002A  *    asterisk
 43  053  2b   002B  +    plus sign
 44  054  2c   002C  ,    comma
 45  055  2d   002D  -    hyphen-minus
 46  056  2e   002E  .    full stop
 47  057  2f   002F  /    solidus
 48  060  30   0030  0    digit zero
 49  061  31   0031  1    digit one
 50  062  32   0032  2    digit two
 51  063  33   0033  3    digit three
 52  064  34   0034  4    digit four
 53  065  35   0035  5    digit five
 54  066  36   0036  6    digit six
 55  067  37   0037  7    digit seven
 56  070  38   0038  8    digit eight
 57  071  39   0039  9    digit nine
 58  072  3a   003A  :    colon
 59  073  3b   003B  ;    semicolon
 60  074  3c   003C  <    less-than sign
 61  075  3d   003D  =    equals sign
 62  076  3e   003E  >    greater-than sign
 63  077  3f   003F  ?    question mark
 64  100  40   0040  @    commercial at
 65  101  41   0041  A    latin capital letter a
 66  102  42   0042  B    latin capital letter b
 67  103  43   0043  C    latin capital letter c
 68  104  44   0044  D    latin capital letter d
 69  105  45   0045  E    latin capital letter e
 70  106  46   0046  F    latin capital letter f
 71  107  47   0047  G    latin capital letter g
 72  110  48   0048  H    latin capital letter h
 73  111  49   0049  I    latin capital letter i
 74  112  4a   004A  J    latin capital letter j
 75  113  4b   004B  K    latin capital letter k
 76  114  4c   004C  L    latin capital letter l
 77  115  4d   004D  M    latin capital letter m
 78  116  4e   004E  N    latin capital letter n
 79  117  4f   004F  O    latin capital letter o
 80  120  50   0050  P    latin capital letter p
 81  121  51   0051  Q    latin capital letter q
 82  122  52   0052  R    latin capital letter r
 83  123  53   0053  S    latin capital letter s
 84  124  54   0054  T    latin capital letter t
 85  125  55   0055  U    latin capital letter u
 86  126  56   0056  V    latin capital letter v
 87  127  57   0057  W    latin capital letter w
 88  130  58   0058  X    latin capital letter x
 89  131  59   0059  Y    latin capital letter y
 90  132  5a   005A  Z    latin capital letter z
 91  133  5b   005B  <(   left square bracket
 92  134  5c   005C  //   reverse solidus
 93  135  5d   005D  )>   right square bracket
 94  136  5e   005E  '>   circumflex accent
 95  137  5f   005F  _    low line
 96  140  60   0060  '!   grave accent
 97  141  61   0061  a    latin small letter a
 98  142  62   0062  b    latin small letter b
 99  143  63   0063  c    latin small letter c
100  144  64   0064  d    latin small letter d
101  145  65   0065  e    latin small letter e
102  146  66   0066  f    latin small letter f
103  147  67   0067  g    latin small letter g
104  150  68   0068  h    latin small letter h
105  151  69   0069  i    latin small letter i
106  152  6a   006A  j    latin small letter j
107  153  6b   006B  k    latin small letter k
108  154  6c   006C  l    latin small letter l
109  155  6d   006D  m    latin small letter m
110  156  6e   006E  n    latin small letter n
111  157  6f   006F  o    latin small letter o
112  160  70   0070  p    latin small letter p
113  161  71   0071  q    latin small letter q
114  162  72   0072  r    latin small letter r
115  163  73   0073  s    latin small letter s
116  164  74   0074  t    latin small letter t
117  165  75   0075  u    latin small letter u
118  166  76   0076  v    latin small letter v
119  167  77   0077  w    latin small letter w
120  170  78   0078  x    latin small letter x
121  171  79   0079  y    latin small letter y
122  172  7a   007A  z    latin small letter z
123  173  7b   007B  (!   left curly bracket
124  174  7c   007C  !!   vertical line
125  175  7d   007D  !)   right curly bracket
126  176  7e   007E  '?   tilde
127  177  7f   007F  DT   delete (del)
128  200  80   0080  PA   padding character (pad)
129  201  81   0081  HO   high octet preset (hop)
130  202  82   0082  BH   break permitted here (bph)
131  203  83   0083  NH   no break here (nbh)
132  204  84   0084  IN   index (ind)
133  205  85   0085  NL   next line (nel)
134  206  86   0086  SA   start of selected area (ssa)
135  207  87   0087  ES   end of selected area (esa)
136  210  88   0088  HS   character tabulation set (hts)
137  211  89   0089  HJ   character tabulation with justification (htj)
138  212  8a   008A  VS   line tabulation set (vts)
139  213  8b   008B  PD   partial line forward (pld)
140  214  8c   008C  PU   partial line backward (plu)
141  215  8d   008D  RI   reverse line feed (ri)
142  216  8e   008E  S2   single-shift two (ss2)
143  217  8f   008F  S3   single-shift three (ss3)
144  220  90   0090  DC   device control string (dcs)
145  221  91   0091  P1   private use one (pu1)
146  222  92   0092  P2   private use two (pu2)
147  223  93   0093  TS   set transmit state (sts)
148  224  94   0094  CC   cancel character (cch)
149  225  95   0095  MW   message waiting (mw)
150  226  96   0096  SG   start of guarded area (spa)
151  227  97   0097  EG   end of guarded area (epa)
152  230  98   0098  SS   start of string (sos)
153  231  99   0099  GC   single graphic character introducer (sgci)
154  232  9a   009A  SC   single character introducer (sci)
155  233  9b   009B  CI   control sequence introducer (csi)
156  234  9c   009C  ST   string terminator (st)
157  235  9d   009D  OC   operating system command (osc)
158  236  9e   009E  PM   privacy message (pm)
159  237  9f   009F  AC   application program command (apc)
160  240  a0   00A0  NS   no-break space
161  241  a1   00A1  !I   inverted exclamation mark
162  242  a2   00A2  Ct   cent sign
163  243  a3   00A3  Pd   pound sign
164  244  a4   00A4  Cu   currency sign
165  245  a5   00A5  Ye   yen sign
166  246  a6   00A6  BB   broken bar
167  247  a7   00A7  SE   section sign
168  250  a8   00A8  ':   diaeresis
169  251  a9   00A9  Co   copyright sign
170  252  aa   00AA  -a   feminine ordinal indicator
171  253  ab   00AB  <<   left-pointing double angle quotation mark
172  254  ac   00AC  NO   not sign
173  255  ad   00AD  --   soft hyphen
174  256  ae   00AE  Rg   registered sign
175  257  af   00AF  'm   macron
176  260  b0   00B0  DG   degree sign
177  261  b1   00B1  +-   plus-minus sign
178  262  b2   00B2  2S   superscript two
179  263  b3   00B3  3S   superscript three
180  264  b4   00B4  ''   acute accent
181  265  b5   00B5  My   micro sign
182  266  b6   00B6  PI   pilcrow sign
183  267  b7   00B7  .M   middle dot
184  270  b8   00B8  ',   cedilla
185  271  b9   00B9  1S   superscript one
186  272  ba   00BA  -o   masculine ordinal indicator
187  273  bb   00BB  >>   right-pointing double angle quotation mark
188  274  bc   00BC  14   vulgar fraction one quarter
189  275  bd   00BD  12   vulgar fraction one half
190  276  be   00BE  34   vulgar fraction three quarters
191  277  bf   00BF  ?I   inverted question mark
192  300  c0   00C0  A!   latin capital letter a with grave
193  301  c1   00C1  A'   latin capital letter a with acute
194  302  c2   00C2  A>   latin capital letter a with circumflex
195  303  c3   00C3  A?   latin capital letter a with tilde
196  304  c4   00C4  A:   latin capital letter a with diaeresis
197  305  c5   00C5  AA   latin capital letter a with ring above
198  306  c6   00C6  AE   latin capital letter ae
199  307  c7   00C7  C,   latin capital letter c with cedilla
200  310  c8   00C8  E!   latin capital letter e with grave
201  311  c9   00C9  E'   latin capital letter e with acute
202  312  ca   00CA  E>   latin capital letter e with circumflex
203  313  cb   00CB  E:   latin capital letter e with diaeresis
204  314  cc   00CC  I!   latin capital letter i with grave
205  315  cd   00CD  I'   latin capital letter i with acute
206  316  ce   00CE  I>   latin capital letter i with circumflex
207  317  cf   00CF  I:   latin capital letter i with diaeresis
208  320  d0   00D0  D-   latin capital letter eth (icelandic)
209  321  d1   00D1  N?   latin capital letter n with tilde
210  322  d2   00D2  O!   latin capital letter o with grave
211  323  d3   00D3  O'   latin capital letter o with acute
212  324  d4   00D4  O>   latin capital letter o with circumflex
213  325  d5   00D5  O?   latin capital letter o with tilde
214  326  d6   00D6  O:   latin capital letter o with diaeresis
215  327  d7   00D7  *X   multiplication sign
216  330  d8   00D8  O/   latin capital letter o with stroke
217  331  d9   00D9  U!   latin capital letter u with grave
218  332  da   00DA  U'   latin capital letter u with acute
219  333  db   00DB  U>   latin capital letter u with circumflex
220  334  dc   00DC  U:   latin capital letter u with diaeresis
221  335  dd   00DD  Y'   latin capital letter y with acute
222  336  de   00DE  TH   latin capital letter thorn (icelandic)
223  337  df   00DF  ss   latin small letter sharp s (german)
224  340  e0   00E0  a!   latin small letter a with grave
225  341  e1   00E1  a'   latin small letter a with acute
226  342  e2   00E2  a>   latin small letter a with circumflex
227  343  e3   00E3  a?   latin small letter a with tilde
228  344  e4   00E4  a:   latin small letter a with diaeresis
229  345  e5   00E5  aa   latin small letter a with ring above
230  346  e6   00E6  ae   latin small letter ae
231  347  e7   00E7  c,   latin small letter c with cedilla
232  350  e8   00E8  e!   latin small letter e with grave
233  351  e9   00E9  e'   latin small letter e with acute
234  352  ea   00EA  e>   latin small letter e with circumflex
235  353  eb   00EB  e:   latin small letter e with diaeresis
236  354  ec   00EC  i!   latin small letter i with grave
237  355  ed   00ED  i'   latin small letter i with acute
238  356  ee   00EE  i>   latin small letter i with circumflex
239  357  ef   00EF  i:   latin small letter i with diaeresis
240  360  f0   00F0  d-   latin small letter eth (icelandic)
241  361  f1   00F1  n?   latin small letter n with tilde
242  362  f2   00F2  o!   latin small letter o with grave
243  363  f3   00F3  o'   latin small letter o with acute
244  364  f4   00F4  o>   latin small letter o with circumflex
245  365  f5   00F5  o?   latin small letter o with tilde
246  366  f6   00F6  o:   latin small letter o with diaeresis
247  367  f7   00F7  -:   division sign
248  370  f8   00F8  o/   latin small letter o with stroke
249  371  f9   00F9  u!   latin small letter u with grave
250  372  fa   00FA  u'   latin small letter u with acute
251  373  fb   00FB  u>   latin small letter u with circumflex
252  374  fc   00FC  u:   latin small letter u with diaeresis
253  375  fd   00FD  y'   latin small letter y with acute
254  376  fe   00FE  th   latin small letter thorn (icelandic)
255  377  ff   00FF  y:   latin small letter y with diaeresis
EOF

test -n "$at_verbose" \
  && echo $srcdir'/lists.m4:402: Testing full listing of a charset'
echo lists.m4:402 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode -lf latin-1 | cmp -s - expect
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s6)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 6"
       ;;
  esac
  at_test_count=6
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expect stdout stderr
  fi
fi

echo
echo 'Individual surfaces.'
echo

# FIXME: tests for endline and permut.

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c7(

rm -rf input output stdout stderr
# Snippet )c7)
  echo dumps.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Decimal-1'
    echo $at_n "     $at_c"
  fi
  echo $at_n "7. $srcdir/dumps.m4:3         $at_c"
  (
# Snippet (s7(

# The test group starts at `dumps.m4:3'.  An error occurred while
# testing single lines to Decimal-1.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:31: Testing single lines to Decimal-1'
echo dumps.m4:31 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../d1 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 10
 97,  10
 97,  98,  10
 97,  98,  99,  10
 97,  98,  99, 100,  10
 97,  98,  99, 100, 101, 102, 103, 104, 105,  10
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115,  10
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 122, 121, 122,  65,  66,  67,  10
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 122, 121, 122,  65,  66,  67,  68,
 69,  70,  71,  72,  73,  74,  75,  76,  77,  10
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 122, 121, 122,  65,  66,  67,  68,
 69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
 84,  85,  86,  87,  10
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 122, 121, 122,  65,  66,  67,  68,
 69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
 84,  85,  86,  87,  88,  89,  90,  48,  49,  50,  51,  52,  53,  54,  10
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s7)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 7"
       ;;
  esac
  at_test_count=7
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c8(

rm -rf input output stdout stderr
# Snippet )c8)
  echo dumps.m4:35 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Decimal-1'
    echo $at_n "     $at_c"
  fi
  echo $at_n "8. $srcdir/dumps.m4:35        $at_c"
  (
# Snippet (s8(

# The test group starts at `dumps.m4:35'.  An error occurred while
# testing block of lines to Decimal-1.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:56: Testing block of lines to Decimal-1'
echo dumps.m4:56 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../d1 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 10,  97,  10,  97,  98,  10,  97,  98,  99,  10,  97,  98,  99, 100,  10,
 97,  98,  99, 100, 101, 102, 103, 104, 105,  10,  97,  98,  99, 100, 101,
102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,  10,
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 122, 121, 122,  65,  66,  67,  10,
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 122, 121, 122,  65,  66,  67,  68,
 69,  70,  71,  72,  73,  74,  75,  76,  77,  10,  97,  98,  99, 100, 101,
102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 118, 119, 122, 121, 122,  65,  66,  67,  68,  69,  70,  71,  72,  73,
 74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  10,
 97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 122, 121, 122,  65,  66,  67,  68,
 69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
 84,  85,  86,  87,  88,  89,  90,  48,  49,  50,  51,  52,  53,  54,  10
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s8)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 8"
       ;;
  esac
  at_test_count=8
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c9(

rm -rf input output stdout stderr
# Snippet )c9)
  echo dumps.m4:60 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Decimal-1 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "9. $srcdir/dumps.m4:60        $at_c"
  (
# Snippet (s9(

# The test group starts at `dumps.m4:60'.  An error occurred while
# testing single lines to Decimal-1 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:73: Testing single lines to Decimal-1 and back'
echo dumps.m4:73 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../d1 output
  recode /d1../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s9)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 9"
       ;;
  esac
  at_test_count=9
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c10(

rm -rf output stdout stderr
# Snippet )c10)
  echo dumps.m4:77 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Decimal-1 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "10. $srcdir/dumps.m4:77       $at_c"
  (
# Snippet (s10(

# The test group starts at `dumps.m4:77'.  An error occurred while
# testing block of lines to Decimal-1 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:88: Testing block of lines to Decimal-1 and back'
echo dumps.m4:88 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../d1 output
recode /d1../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s10)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 10"
       ;;
  esac
  at_test_count=10
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c11(

rm -rf input output stdout stderr
# Snippet )c11)
  echo dumps.m4:92 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Decimal-2'
    echo $at_n "     $at_c"
  fi
  echo $at_n "11. $srcdir/dumps.m4:92       $at_c"
  (
# Snippet (s11(

# The test group starts at `dumps.m4:92'.  An error occurred while
# testing single lines to Decimal-2.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:116: Testing single lines to Decimal-2'
echo dumps.m4:116 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../d2 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 10
24842
24930,  10
24930, 25354
24930, 25444,  10
24930, 25444, 25958, 26472, 26890
24930, 25444, 25958, 26472, 26986, 27500, 28014, 28528, 29042, 29450
24930, 25444, 25958, 26472, 26986, 27500, 28014, 28528, 29042, 29556,
30070, 30586, 31098, 16706, 17162
24930, 25444, 25958, 26472, 26986, 27500, 28014, 28528, 29042, 29556,
30070, 30586, 31098, 16706, 17220, 17734, 18248, 18762, 19276, 19722
24930, 25444, 25958, 26472, 26986, 27500, 28014, 28528, 29042, 29556,
30070, 30586, 31098, 16706, 17220, 17734, 18248, 18762, 19276, 19790,
20304, 20818, 21332, 21846, 22282
24930, 25444, 25958, 26472, 26986, 27500, 28014, 28528, 29042, 29556,
30070, 30586, 31098, 16706, 17220, 17734, 18248, 18762, 19276, 19790,
20304, 20818, 21332, 21846, 22360, 22874, 12337, 12851, 13365, 13834
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s11)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 11"
       ;;
  esac
  at_test_count=11
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c12(

rm -rf input output stdout stderr
# Snippet )c12)
  echo dumps.m4:120 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Decimal-2'
    echo $at_n "     $at_c"
  fi
  echo $at_n "12. $srcdir/dumps.m4:120      $at_c"
  (
# Snippet (s12(

# The test group starts at `dumps.m4:120'.  An error occurred while
# testing block of lines to Decimal-2.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:138: Testing block of lines to Decimal-2'
echo dumps.m4:138 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../d2 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 2657,  2657, 25098, 24930, 25354, 24930, 25444,  2657, 25187, 25701,
26215, 26729,  2657, 25187, 25701, 26215, 26729, 27243, 27757, 28271,
28785, 29299,  2657, 25187, 25701, 26215, 26729, 27243, 27757, 28271,
28785, 29299, 29813, 30327, 31353, 31297, 16963,  2657, 25187, 25701,
26215, 26729, 27243, 27757, 28271, 28785, 29299, 29813, 30327, 31353,
31297, 16963, 17477, 17991, 18505, 19019, 19533,  2657, 25187, 25701,
26215, 26729, 27243, 27757, 28271, 28785, 29299, 29813, 30327, 31353,
31297, 16963, 17477, 17991, 18505, 19019, 19533, 20047, 20561, 21075,
21589, 22103,  2657, 25187, 25701, 26215, 26729, 27243, 27757, 28271,
28785, 29299, 29813, 30327, 31353, 31297, 16963, 17477, 17991, 18505,
19019, 19533, 20047, 20561, 21075, 21589, 22103, 22617, 23088, 12594,
13108, 13622,  10
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s12)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 12"
       ;;
  esac
  at_test_count=12
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c13(

rm -rf input output stdout stderr
# Snippet )c13)
  echo dumps.m4:142 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Decimal-2 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "13. $srcdir/dumps.m4:142      $at_c"
  (
# Snippet (s13(

# The test group starts at `dumps.m4:142'.  An error occurred while
# testing single lines to Decimal-2 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:155: Testing single lines to Decimal-2 and back'
echo dumps.m4:155 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../d2 output
  recode /d2../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s13)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 13"
       ;;
  esac
  at_test_count=13
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c14(

rm -rf output stdout stderr
# Snippet )c14)
  echo dumps.m4:159 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Decimal-2 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "14. $srcdir/dumps.m4:159      $at_c"
  (
# Snippet (s14(

# The test group starts at `dumps.m4:159'.  An error occurred while
# testing block of lines to Decimal-2 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:170: Testing block of lines to Decimal-2 and back'
echo dumps.m4:170 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../d2 output
recode /d2../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s14)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 14"
       ;;
  esac
  at_test_count=14
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c15(

rm -rf input output stdout stderr
# Snippet )c15)
  echo dumps.m4:174 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Decimal-4'
    echo $at_n "     $at_c"
  fi
  echo $at_n "15. $srcdir/dumps.m4:174      $at_c"
  (
# Snippet (s15(

# The test group starts at `dumps.m4:174'.  An error occurred while
# testing single lines to Decimal-4.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:198: Testing single lines to Decimal-4'
echo dumps.m4:198 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../d4 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 10
24842
 6382090
1633837834
1633837924,  10
1633837924, 1701209960, 26890
1633837924, 1701209960, 1768581996, 1835954032, 1903325962
1633837924, 1701209960, 1768581996, 1835954032, 1903326068,
1970698106, 2038055234, 17162
1633837924, 1701209960, 1768581996, 1835954032, 1903326068,
1970698106, 2038055234, 1128547654, 1195919690, 1263291658
1633837924, 1701209960, 1768581996, 1835954032, 1903326068,
1970698106, 2038055234, 1128547654, 1195919690, 1263291726,
1330663762, 1398035798, 22282
1633837924, 1701209960, 1768581996, 1835954032, 1903326068,
1970698106, 2038055234, 1128547654, 1195919690, 1263291726,
1330663762, 1398035798, 1465407834,  808530483,  875902474
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s15)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 15"
       ;;
  esac
  at_test_count=15
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c16(

rm -rf input output stdout stderr
# Snippet )c16)
  echo dumps.m4:202 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Decimal-4'
    echo $at_n "     $at_c"
  fi
  echo $at_n "16. $srcdir/dumps.m4:202      $at_c"
  (
# Snippet (s16(

# The test group starts at `dumps.m4:202'.  An error occurred while
# testing block of lines to Decimal-4.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:220: Testing block of lines to Decimal-4'
echo dumps.m4:220 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../d4 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 174131809, 1644847458, 1661624674, 1667500641, 1650680933,
1718052969,  174154339, 1684366951, 1751738987, 1819111023,
1886483059,  174154339, 1684366951, 1751738987, 1819111023,
1886483059, 1953855095, 2054781505, 1111689825, 1650680933,
1718052969, 1785425005, 1852797041, 1920169077, 1987541625,
2051097155, 1145390663, 1212762699, 1280117345, 1650680933,
1718052969, 1785425005, 1852797041, 1920169077, 1987541625,
2051097155, 1145390663, 1212762699, 1280134735, 1347506771,
1414878807,  174154339, 1684366951, 1751738987, 1819111023,
1886483059, 1953855095, 2054781505, 1111704645, 1179076681,
1246448717, 1313820753, 1381192789, 1448564825, 1513107762,
 859059510,  10
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s16)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 16"
       ;;
  esac
  at_test_count=16
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c17(

rm -rf input output stdout stderr
# Snippet )c17)
  echo dumps.m4:224 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Decimal-4 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "17. $srcdir/dumps.m4:224      $at_c"
  (
# Snippet (s17(

# The test group starts at `dumps.m4:224'.  An error occurred while
# testing single lines to Decimal-4 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:237: Testing single lines to Decimal-4 and back'
echo dumps.m4:237 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../d4 output
  recode /d4../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s17)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 17"
       ;;
  esac
  at_test_count=17
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c18(

rm -rf output stdout stderr
# Snippet )c18)
  echo dumps.m4:241 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Decimal-4 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "18. $srcdir/dumps.m4:241      $at_c"
  (
# Snippet (s18(

# The test group starts at `dumps.m4:241'.  An error occurred while
# testing block of lines to Decimal-4 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:252: Testing block of lines to Decimal-4 and back'
echo dumps.m4:252 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../d4 output
recode /d4../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s18)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 18"
       ;;
  esac
  at_test_count=18
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c19(

rm -rf input output stdout stderr
# Snippet )c19)
  echo dumps.m4:256 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Hexadecimal-1'
    echo $at_n "     $at_c"
  fi
  echo $at_n "19. $srcdir/dumps.m4:256      $at_c"
  (
# Snippet (s19(

# The test group starts at `dumps.m4:256'.  An error occurred while
# testing single lines to Hexadecimal-1.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:288: Testing single lines to Hexadecimal-1'
echo dumps.m4:288 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../x1 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x0A
0x61, 0x0A
0x61, 0x62, 0x0A
0x61, 0x62, 0x63, 0x0A
0x61, 0x62, 0x63, 0x64, 0x0A
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x0A
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x0A
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x7A,
0x79, 0x7A, 0x41, 0x42, 0x43, 0x0A
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x7A,
0x79, 0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
0x4B, 0x4C, 0x4D, 0x0A
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x7A,
0x79, 0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
0x57, 0x0A
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x7A,
0x79, 0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
0x57, 0x58, 0x59, 0x5A, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x0A
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s19)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 19"
       ;;
  esac
  at_test_count=19
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c20(

rm -rf input output stdout stderr
# Snippet )c20)
  echo dumps.m4:292 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Hexadecimal-1'
    echo $at_n "     $at_c"
  fi
  echo $at_n "20. $srcdir/dumps.m4:292      $at_c"
  (
# Snippet (s20(

# The test group starts at `dumps.m4:292'.  An error occurred while
# testing block of lines to Hexadecimal-1.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:317: Testing block of lines to Hexadecimal-1'
echo dumps.m4:317 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../x1 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x0A, 0x61, 0x0A, 0x61, 0x62, 0x0A, 0x61, 0x62, 0x63, 0x0A, 0x61, 0x62,
0x63, 0x64, 0x0A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
0x0A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B,
0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x0A, 0x61, 0x62, 0x63,
0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x7A, 0x79, 0x7A, 0x41,
0x42, 0x43, 0x0A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
0x76, 0x77, 0x7A, 0x79, 0x7A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x0A, 0x61, 0x62, 0x63, 0x64, 0x65,
0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x7A, 0x79, 0x7A, 0x41, 0x42, 0x43,
0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x0A, 0x61, 0x62, 0x63,
0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x7A, 0x79, 0x7A, 0x41,
0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D,
0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5A, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x0A
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s20)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 20"
       ;;
  esac
  at_test_count=20
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c21(

rm -rf input output stdout stderr
# Snippet )c21)
  echo dumps.m4:321 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Hexadecimal-1 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "21. $srcdir/dumps.m4:321      $at_c"
  (
# Snippet (s21(

# The test group starts at `dumps.m4:321'.  An error occurred while
# testing single lines to Hexadecimal-1 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:334: Testing single lines to Hexadecimal-1 and back'
echo dumps.m4:334 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../x1 output
  recode /x1../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s21)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 21"
       ;;
  esac
  at_test_count=21
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c22(

rm -rf output stdout stderr
# Snippet )c22)
  echo dumps.m4:338 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Hexadecimal-1 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "22. $srcdir/dumps.m4:338      $at_c"
  (
# Snippet (s22(

# The test group starts at `dumps.m4:338'.  An error occurred while
# testing block of lines to Hexadecimal-1 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:349: Testing block of lines to Hexadecimal-1 and back'
echo dumps.m4:349 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../x1 output
recode /x1../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s22)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 22"
       ;;
  esac
  at_test_count=22
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c23(

rm -rf input output stdout stderr
# Snippet )c23)
  echo dumps.m4:353 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Hexadecimal-2'
    echo $at_n "     $at_c"
  fi
  echo $at_n "23. $srcdir/dumps.m4:353      $at_c"
  (
# Snippet (s23(

# The test group starts at `dumps.m4:353'.  An error occurred while
# testing single lines to Hexadecimal-2.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:381: Testing single lines to Hexadecimal-2'
echo dumps.m4:381 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../x2 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x0A
0x610A
0x6162, 0x0A
0x6162, 0x630A
0x6162, 0x6364, 0x0A
0x6162, 0x6364, 0x6566, 0x6768, 0x690A
0x6162, 0x6364, 0x6566, 0x6768, 0x696A, 0x6B6C, 0x6D6E, 0x6F70,
0x7172, 0x730A
0x6162, 0x6364, 0x6566, 0x6768, 0x696A, 0x6B6C, 0x6D6E, 0x6F70,
0x7172, 0x7374, 0x7576, 0x777A, 0x797A, 0x4142, 0x430A
0x6162, 0x6364, 0x6566, 0x6768, 0x696A, 0x6B6C, 0x6D6E, 0x6F70,
0x7172, 0x7374, 0x7576, 0x777A, 0x797A, 0x4142, 0x4344, 0x4546,
0x4748, 0x494A, 0x4B4C, 0x4D0A
0x6162, 0x6364, 0x6566, 0x6768, 0x696A, 0x6B6C, 0x6D6E, 0x6F70,
0x7172, 0x7374, 0x7576, 0x777A, 0x797A, 0x4142, 0x4344, 0x4546,
0x4748, 0x494A, 0x4B4C, 0x4D4E, 0x4F50, 0x5152, 0x5354, 0x5556,
0x570A
0x6162, 0x6364, 0x6566, 0x6768, 0x696A, 0x6B6C, 0x6D6E, 0x6F70,
0x7172, 0x7374, 0x7576, 0x777A, 0x797A, 0x4142, 0x4344, 0x4546,
0x4748, 0x494A, 0x4B4C, 0x4D4E, 0x4F50, 0x5152, 0x5354, 0x5556,
0x5758, 0x595A, 0x3031, 0x3233, 0x3435, 0x360A
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s23)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 23"
       ;;
  esac
  at_test_count=23
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c24(

rm -rf input output stdout stderr
# Snippet )c24)
  echo dumps.m4:385 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Hexadecimal-2'
    echo $at_n "     $at_c"
  fi
  echo $at_n "24. $srcdir/dumps.m4:385      $at_c"
  (
# Snippet (s24(

# The test group starts at `dumps.m4:385'.  An error occurred while
# testing block of lines to Hexadecimal-2.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:406: Testing block of lines to Hexadecimal-2'
echo dumps.m4:406 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../x2 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x0A61, 0x0A61, 0x620A, 0x6162, 0x630A, 0x6162, 0x6364, 0x0A61,
0x6263, 0x6465, 0x6667, 0x6869, 0x0A61, 0x6263, 0x6465, 0x6667,
0x6869, 0x6A6B, 0x6C6D, 0x6E6F, 0x7071, 0x7273, 0x0A61, 0x6263,
0x6465, 0x6667, 0x6869, 0x6A6B, 0x6C6D, 0x6E6F, 0x7071, 0x7273,
0x7475, 0x7677, 0x7A79, 0x7A41, 0x4243, 0x0A61, 0x6263, 0x6465,
0x6667, 0x6869, 0x6A6B, 0x6C6D, 0x6E6F, 0x7071, 0x7273, 0x7475,
0x7677, 0x7A79, 0x7A41, 0x4243, 0x4445, 0x4647, 0x4849, 0x4A4B,
0x4C4D, 0x0A61, 0x6263, 0x6465, 0x6667, 0x6869, 0x6A6B, 0x6C6D,
0x6E6F, 0x7071, 0x7273, 0x7475, 0x7677, 0x7A79, 0x7A41, 0x4243,
0x4445, 0x4647, 0x4849, 0x4A4B, 0x4C4D, 0x4E4F, 0x5051, 0x5253,
0x5455, 0x5657, 0x0A61, 0x6263, 0x6465, 0x6667, 0x6869, 0x6A6B,
0x6C6D, 0x6E6F, 0x7071, 0x7273, 0x7475, 0x7677, 0x7A79, 0x7A41,
0x4243, 0x4445, 0x4647, 0x4849, 0x4A4B, 0x4C4D, 0x4E4F, 0x5051,
0x5253, 0x5455, 0x5657, 0x5859, 0x5A30, 0x3132, 0x3334, 0x3536,
0x0A
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s24)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 24"
       ;;
  esac
  at_test_count=24
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c25(

rm -rf input output stdout stderr
# Snippet )c25)
  echo dumps.m4:410 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Hexadecimal-2 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "25. $srcdir/dumps.m4:410      $at_c"
  (
# Snippet (s25(

# The test group starts at `dumps.m4:410'.  An error occurred while
# testing single lines to Hexadecimal-2 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:423: Testing single lines to Hexadecimal-2 and back'
echo dumps.m4:423 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../x2 output
  recode /x2../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s25)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 25"
       ;;
  esac
  at_test_count=25
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c26(

rm -rf output stdout stderr
# Snippet )c26)
  echo dumps.m4:427 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Hexadecimal-2 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "26. $srcdir/dumps.m4:427      $at_c"
  (
# Snippet (s26(

# The test group starts at `dumps.m4:427'.  An error occurred while
# testing block of lines to Hexadecimal-2 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:438: Testing block of lines to Hexadecimal-2 and back'
echo dumps.m4:438 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../x2 output
recode /x2../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s26)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 26"
       ;;
  esac
  at_test_count=26
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c27(

rm -rf input output stdout stderr
# Snippet )c27)
  echo dumps.m4:442 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Hexadecimal-4'
    echo $at_n "     $at_c"
  fi
  echo $at_n "27. $srcdir/dumps.m4:442      $at_c"
  (
# Snippet (s27(

# The test group starts at `dumps.m4:442'.  An error occurred while
# testing single lines to Hexadecimal-4.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:466: Testing single lines to Hexadecimal-4'
echo dumps.m4:466 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../x4 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x0A
0x610A
0x61620A
0x6162630A
0x61626364, 0x0A
0x61626364, 0x65666768, 0x690A
0x61626364, 0x65666768, 0x696A6B6C, 0x6D6E6F70, 0x7172730A
0x61626364, 0x65666768, 0x696A6B6C, 0x6D6E6F70, 0x71727374, 0x7576777A,
0x797A4142, 0x430A
0x61626364, 0x65666768, 0x696A6B6C, 0x6D6E6F70, 0x71727374, 0x7576777A,
0x797A4142, 0x43444546, 0x4748494A, 0x4B4C4D0A
0x61626364, 0x65666768, 0x696A6B6C, 0x6D6E6F70, 0x71727374, 0x7576777A,
0x797A4142, 0x43444546, 0x4748494A, 0x4B4C4D4E, 0x4F505152, 0x53545556,
0x570A
0x61626364, 0x65666768, 0x696A6B6C, 0x6D6E6F70, 0x71727374, 0x7576777A,
0x797A4142, 0x43444546, 0x4748494A, 0x4B4C4D4E, 0x4F505152, 0x53545556,
0x5758595A, 0x30313233, 0x3435360A
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s27)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 27"
       ;;
  esac
  at_test_count=27
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c28(

rm -rf input output stdout stderr
# Snippet )c28)
  echo dumps.m4:470 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Hexadecimal-4'
    echo $at_n "     $at_c"
  fi
  echo $at_n "28. $srcdir/dumps.m4:470      $at_c"
  (
# Snippet (s28(

# The test group starts at `dumps.m4:470'.  An error occurred while
# testing block of lines to Hexadecimal-4.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:486: Testing block of lines to Hexadecimal-4'
echo dumps.m4:486 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../x4 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x0A610A61, 0x620A6162, 0x630A6162, 0x63640A61, 0x62636465, 0x66676869,
0x0A616263, 0x64656667, 0x68696A6B, 0x6C6D6E6F, 0x70717273, 0x0A616263,
0x64656667, 0x68696A6B, 0x6C6D6E6F, 0x70717273, 0x74757677, 0x7A797A41,
0x42430A61, 0x62636465, 0x66676869, 0x6A6B6C6D, 0x6E6F7071, 0x72737475,
0x76777A79, 0x7A414243, 0x44454647, 0x48494A4B, 0x4C4D0A61, 0x62636465,
0x66676869, 0x6A6B6C6D, 0x6E6F7071, 0x72737475, 0x76777A79, 0x7A414243,
0x44454647, 0x48494A4B, 0x4C4D4E4F, 0x50515253, 0x54555657, 0x0A616263,
0x64656667, 0x68696A6B, 0x6C6D6E6F, 0x70717273, 0x74757677, 0x7A797A41,
0x42434445, 0x46474849, 0x4A4B4C4D, 0x4E4F5051, 0x52535455, 0x56575859,
0x5A303132, 0x33343536, 0x0A
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s28)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 28"
       ;;
  esac
  at_test_count=28
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c29(

rm -rf input output stdout stderr
# Snippet )c29)
  echo dumps.m4:490 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Hexadecimal-4 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "29. $srcdir/dumps.m4:490      $at_c"
  (
# Snippet (s29(

# The test group starts at `dumps.m4:490'.  An error occurred while
# testing single lines to Hexadecimal-4 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:503: Testing single lines to Hexadecimal-4 and back'
echo dumps.m4:503 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../x4 output
  recode /x4../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s29)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 29"
       ;;
  esac
  at_test_count=29
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c30(

rm -rf output stdout stderr
# Snippet )c30)
  echo dumps.m4:507 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Hexadecimal-4 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "30. $srcdir/dumps.m4:507      $at_c"
  (
# Snippet (s30(

# The test group starts at `dumps.m4:507'.  An error occurred while
# testing block of lines to Hexadecimal-4 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:518: Testing block of lines to Hexadecimal-4 and back'
echo dumps.m4:518 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../x4 output
recode /x4../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s30)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 30"
       ;;
  esac
  at_test_count=30
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c31(

rm -rf input output stdout stderr
# Snippet )c31)
  echo dumps.m4:522 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Octal-1'
    echo $at_n "     $at_c"
  fi
  echo $at_n "31. $srcdir/dumps.m4:522      $at_c"
  (
# Snippet (s31(

# The test group starts at `dumps.m4:522'.  An error occurred while
# testing single lines to Octal-1.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:554: Testing single lines to Octal-1'
echo dumps.m4:554 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../o1 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0012
0141, 0012
0141, 0142, 0012
0141, 0142, 0143, 0012
0141, 0142, 0143, 0144, 0012
0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151, 0012
0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153, 0154,
0155, 0156, 0157, 0160, 0161, 0162, 0163, 0012
0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153, 0154,
0155, 0156, 0157, 0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167, 0172,
0171, 0172, 0101, 0102, 0103, 0012
0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153, 0154,
0155, 0156, 0157, 0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167, 0172,
0171, 0172, 0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110, 0111, 0112,
0113, 0114, 0115, 0012
0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153, 0154,
0155, 0156, 0157, 0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167, 0172,
0171, 0172, 0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110, 0111, 0112,
0113, 0114, 0115, 0116, 0117, 0120, 0121, 0122, 0123, 0124, 0125, 0126,
0127, 0012
0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153, 0154,
0155, 0156, 0157, 0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167, 0172,
0171, 0172, 0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110, 0111, 0112,
0113, 0114, 0115, 0116, 0117, 0120, 0121, 0122, 0123, 0124, 0125, 0126,
0127, 0130, 0131, 0132, 0060, 0061, 0062, 0063, 0064, 0065, 0066, 0012
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s31)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 31"
       ;;
  esac
  at_test_count=31
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c32(

rm -rf input output stdout stderr
# Snippet )c32)
  echo dumps.m4:558 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Octal-1'
    echo $at_n "     $at_c"
  fi
  echo $at_n "32. $srcdir/dumps.m4:558      $at_c"
  (
# Snippet (s32(

# The test group starts at `dumps.m4:558'.  An error occurred while
# testing block of lines to Octal-1.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:583: Testing block of lines to Octal-1'
echo dumps.m4:583 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../o1 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0012, 0141, 0012, 0141, 0142, 0012, 0141, 0142, 0143, 0012, 0141, 0142,
0143, 0144, 0012, 0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151,
0012, 0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153,
0154, 0155, 0156, 0157, 0160, 0161, 0162, 0163, 0012, 0141, 0142, 0143,
0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167, 0172, 0171, 0172, 0101,
0102, 0103, 0012, 0141, 0142, 0143, 0144, 0145, 0146, 0147, 0150, 0151,
0152, 0153, 0154, 0155, 0156, 0157, 0160, 0161, 0162, 0163, 0164, 0165,
0166, 0167, 0172, 0171, 0172, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
0110, 0111, 0112, 0113, 0114, 0115, 0012, 0141, 0142, 0143, 0144, 0145,
0146, 0147, 0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157, 0160, 0161,
0162, 0163, 0164, 0165, 0166, 0167, 0172, 0171, 0172, 0101, 0102, 0103,
0104, 0105, 0106, 0107, 0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117,
0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, 0012, 0141, 0142, 0143,
0144, 0145, 0146, 0147, 0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167, 0172, 0171, 0172, 0101,
0102, 0103, 0104, 0105, 0106, 0107, 0110, 0111, 0112, 0113, 0114, 0115,
0116, 0117, 0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, 0130, 0131,
0132, 0060, 0061, 0062, 0063, 0064, 0065, 0066, 0012
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s32)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 32"
       ;;
  esac
  at_test_count=32
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c33(

rm -rf input output stdout stderr
# Snippet )c33)
  echo dumps.m4:587 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Octal-1 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "33. $srcdir/dumps.m4:587      $at_c"
  (
# Snippet (s33(

# The test group starts at `dumps.m4:587'.  An error occurred while
# testing single lines to Octal-1 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:600: Testing single lines to Octal-1 and back'
echo dumps.m4:600 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../o1 output
  recode /o1../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s33)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 33"
       ;;
  esac
  at_test_count=33
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c34(

rm -rf output stdout stderr
# Snippet )c34)
  echo dumps.m4:604 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Octal-1 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "34. $srcdir/dumps.m4:604      $at_c"
  (
# Snippet (s34(

# The test group starts at `dumps.m4:604'.  An error occurred while
# testing block of lines to Octal-1 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:615: Testing block of lines to Octal-1 and back'
echo dumps.m4:615 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../o1 output
recode /o1../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s34)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 34"
       ;;
  esac
  at_test_count=34
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c35(

rm -rf input output stdout stderr
# Snippet )c35)
  echo dumps.m4:619 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Octal-2'
    echo $at_n "     $at_c"
  fi
  echo $at_n "35. $srcdir/dumps.m4:619      $at_c"
  (
# Snippet (s35(

# The test group starts at `dumps.m4:619'.  An error occurred while
# testing single lines to Octal-2.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:647: Testing single lines to Octal-2'
echo dumps.m4:647 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../o2 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0012
0060412
0060542, 0012
0060542, 0061412
0060542, 0061544, 0012
0060542, 0061544, 0062546, 0063550, 0064412
0060542, 0061544, 0062546, 0063550, 0064552, 0065554, 0066556, 0067560,
0070562, 0071412
0060542, 0061544, 0062546, 0063550, 0064552, 0065554, 0066556, 0067560,
0070562, 0071564, 0072566, 0073572, 0074572, 0040502, 0041412
0060542, 0061544, 0062546, 0063550, 0064552, 0065554, 0066556, 0067560,
0070562, 0071564, 0072566, 0073572, 0074572, 0040502, 0041504, 0042506,
0043510, 0044512, 0045514, 0046412
0060542, 0061544, 0062546, 0063550, 0064552, 0065554, 0066556, 0067560,
0070562, 0071564, 0072566, 0073572, 0074572, 0040502, 0041504, 0042506,
0043510, 0044512, 0045514, 0046516, 0047520, 0050522, 0051524, 0052526,
0053412
0060542, 0061544, 0062546, 0063550, 0064552, 0065554, 0066556, 0067560,
0070562, 0071564, 0072566, 0073572, 0074572, 0040502, 0041504, 0042506,
0043510, 0044512, 0045514, 0046516, 0047520, 0050522, 0051524, 0052526,
0053530, 0054532, 0030061, 0031063, 0032065, 0033012
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s35)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 35"
       ;;
  esac
  at_test_count=35
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c36(

rm -rf input output stdout stderr
# Snippet )c36)
  echo dumps.m4:651 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Octal-2'
    echo $at_n "     $at_c"
  fi
  echo $at_n "36. $srcdir/dumps.m4:651      $at_c"
  (
# Snippet (s36(

# The test group starts at `dumps.m4:651'.  An error occurred while
# testing block of lines to Octal-2.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:672: Testing block of lines to Octal-2'
echo dumps.m4:672 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../o2 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0005141, 0005141, 0061012, 0060542, 0061412, 0060542, 0061544, 0005141,
0061143, 0062145, 0063147, 0064151, 0005141, 0061143, 0062145, 0063147,
0064151, 0065153, 0066155, 0067157, 0070161, 0071163, 0005141, 0061143,
0062145, 0063147, 0064151, 0065153, 0066155, 0067157, 0070161, 0071163,
0072165, 0073167, 0075171, 0075101, 0041103, 0005141, 0061143, 0062145,
0063147, 0064151, 0065153, 0066155, 0067157, 0070161, 0071163, 0072165,
0073167, 0075171, 0075101, 0041103, 0042105, 0043107, 0044111, 0045113,
0046115, 0005141, 0061143, 0062145, 0063147, 0064151, 0065153, 0066155,
0067157, 0070161, 0071163, 0072165, 0073167, 0075171, 0075101, 0041103,
0042105, 0043107, 0044111, 0045113, 0046115, 0047117, 0050121, 0051123,
0052125, 0053127, 0005141, 0061143, 0062145, 0063147, 0064151, 0065153,
0066155, 0067157, 0070161, 0071163, 0072165, 0073167, 0075171, 0075101,
0041103, 0042105, 0043107, 0044111, 0045113, 0046115, 0047117, 0050121,
0051123, 0052125, 0053127, 0054131, 0055060, 0030462, 0031464, 0032466,
0012
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s36)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 36"
       ;;
  esac
  at_test_count=36
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c37(

rm -rf input output stdout stderr
# Snippet )c37)
  echo dumps.m4:676 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Octal-2 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "37. $srcdir/dumps.m4:676      $at_c"
  (
# Snippet (s37(

# The test group starts at `dumps.m4:676'.  An error occurred while
# testing single lines to Octal-2 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:689: Testing single lines to Octal-2 and back'
echo dumps.m4:689 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../o2 output
  recode /o2../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s37)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 37"
       ;;
  esac
  at_test_count=37
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c38(

rm -rf output stdout stderr
# Snippet )c38)
  echo dumps.m4:693 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Octal-2 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "38. $srcdir/dumps.m4:693      $at_c"
  (
# Snippet (s38(

# The test group starts at `dumps.m4:693'.  An error occurred while
# testing block of lines to Octal-2 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:704: Testing block of lines to Octal-2 and back'
echo dumps.m4:704 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../o2 output
recode /o2../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s38)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 38"
       ;;
  esac
  at_test_count=38
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c39(

rm -rf input output stdout stderr
# Snippet )c39)
  echo dumps.m4:708 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Octal-4'
    echo $at_n "     $at_c"
  fi
  echo $at_n "39. $srcdir/dumps.m4:708      $at_c"
  (
# Snippet (s39(

# The test group starts at `dumps.m4:708'.  An error occurred while
# testing single lines to Octal-4.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:736: Testing single lines to Octal-4'
echo dumps.m4:736 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../o4 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0012
0060412
030261012
014130461412
014130461544, 0012
014130461544, 014531463550, 0064412
014130461544, 014531463550, 015132465554, 015533467560,
016134471412
014130461544, 014531463550, 015132465554, 015533467560,
016134471564, 016535473572, 017136440502, 0041412
014130461544, 014531463550, 015132465554, 015533467560,
016134471564, 016535473572, 017136440502, 010321042506,
010722044512, 011323046412
014130461544, 014531463550, 015132465554, 015533467560,
016134471564, 016535473572, 017136440502, 010321042506,
010722044512, 011323046516, 011724050522, 012325052526,
0053412
014130461544, 014531463550, 015132465554, 015533467560,
016134471564, 016535473572, 017136440502, 010321042506,
010722044512, 011323046516, 011724050522, 012325052526,
012726054532, 006014231063, 006415233012
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s39)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 39"
       ;;
  esac
  at_test_count=39
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c40(

rm -rf input output stdout stderr
# Snippet )c40)
  echo dumps.m4:740 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Octal-4'
    echo $at_n "     $at_c"
  fi
  echo $at_n "40. $srcdir/dumps.m4:740      $at_c"
  (
# Snippet (s40(

# The test group starts at `dumps.m4:740'.  An error occurred while
# testing block of lines to Octal-4.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:761: Testing block of lines to Octal-4'
echo dumps.m4:761 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../o4 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "001230205141, 014202460542, 014302460542, 014331005141,
014230662145, 014631664151, 001230261143, 014431263147,
015032265153, 015433267157, 016034271163, 001230261143,
014431263147, 015032265153, 015433267157, 016034271163,
016435273167, 017236275101, 010220605141, 014230662145,
014631664151, 015232666155, 015633670161, 016234672165,
016635675171, 017220241103, 010421243107, 011022245113,
011423205141, 014230662145, 014631664151, 015232666155,
015633670161, 016234672165, 016635675171, 017220241103,
010421243107, 011022245113, 011423247117, 012024251123,
012425253127, 001230261143, 014431263147, 015032265153,
015433267157, 016034271163, 016435273167, 017236275101,
010220642105, 010621644111, 011222646115, 011623650121,
012224652125, 012625654131, 013214030462, 006315032466,
0012
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s40)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 40"
       ;;
  esac
  at_test_count=40
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c41(

rm -rf input output stdout stderr
# Snippet )c41)
  echo dumps.m4:765 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Octal-4 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "41. $srcdir/dumps.m4:765      $at_c"
  (
# Snippet (s41(

# The test group starts at `dumps.m4:765'.  An error occurred while
# testing single lines to Octal-4 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:778: Testing single lines to Octal-4 and back'
echo dumps.m4:778 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../o4 output
  recode /o4../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s41)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 41"
       ;;
  esac
  at_test_count=41
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c42(

rm -rf output stdout stderr
# Snippet )c42)
  echo dumps.m4:782 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Octal-4 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "42. $srcdir/dumps.m4:782      $at_c"
  (
# Snippet (s42(

# The test group starts at `dumps.m4:782'.  An error occurred while
# testing block of lines to Octal-4 and back.

test -n "$at_verbose" \
  && echo $srcdir'/dumps.m4:793: Testing block of lines to Octal-4 and back'
echo dumps.m4:793 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../o4 output
recode /o4../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s42)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 42"
       ;;
  esac
  at_test_count=42
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c43(

rm -rf stdout stderr
# Snippet )c43)
  echo base64.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Base64'
    echo $at_n "     $at_c"
  fi
  echo $at_n "43. $srcdir/base64.m4:3       $at_c"
  (
# Snippet (s43(

# The test group starts at `base64.m4:3'.  An error occurred while
# testing single lines to Base64.

test -n "$at_verbose" \
  && echo $srcdir'/base64.m4:22: Testing single lines to Base64'
echo base64.m4:22 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
( while read line; do echo $line | recode ../64 || exit 1; done
) < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "Cg==
YQo=
YWIK
YWJjCg==
YWJjZAo=
YWJjZGVmZ2hpCg==
YWJjZGVmZ2hpamtsbW5vcHFycwo=
YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd6eXpBQkMK
YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd6eXpBQkNERUZHSElKS0xNCg==
YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd6eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWVwo=
YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd6eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0
NTYK
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s43)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 43"
       ;;
  esac
  at_test_count=43
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c44(

rm -rf stdout stderr
# Snippet )c44)
  echo base64.m4:26 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Base64'
    echo $at_n "     $at_c"
  fi
  echo $at_n "44. $srcdir/base64.m4:26      $at_c"
  (
# Snippet (s44(

# The test group starts at `base64.m4:26'.  An error occurred while
# testing block of lines to Base64.

test -n "$at_verbose" \
  && echo $srcdir'/base64.m4:36: Testing block of lines to Base64'
echo base64.m4:36 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode /../64 < $at_srcdir/dumps-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "CmEKYWIKYWJjCmFiY2QKYWJjZGVmZ2hpCmFiY2RlZmdoaWprbG1ub3BxcnMKYWJjZGVmZ2hpamts
bW5vcHFyc3R1dnd6eXpBQkMKYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd6eXpBQkNERUZHSElKS0xN
CmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3enl6QUJDREVGR0hJSktMTU5PUFFSU1RVVlcKYWJjZGVm
Z2hpamtsbW5vcHFyc3R1dnd6eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTYK
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s44)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 44"
       ;;
  esac
  at_test_count=44
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c45(

rm -rf input output stdout stderr
# Snippet )c45)
  echo base64.m4:40 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines to Base64 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "45. $srcdir/base64.m4:40      $at_c"
  (
# Snippet (s45(

# The test group starts at `base64.m4:40'.  An error occurred while
# testing single lines to Base64 and back.

test -n "$at_verbose" \
  && echo $srcdir'/base64.m4:53: Testing single lines to Base64 and back'
echo base64.m4:53 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo $line > input
  echo $line > output
  recode /../64 output
  recode /64../ output
  diff input output
done < $at_srcdir/dumps-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s45)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 45"
       ;;
  esac
  at_test_count=45
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c46(

rm -rf output stdout stderr
# Snippet )c46)
  echo base64.m4:57 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to Base64 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "46. $srcdir/base64.m4:57      $at_c"
  (
# Snippet (s46(

# The test group starts at `base64.m4:57'.  An error occurred while
# testing block of lines to Base64 and back.

test -n "$at_verbose" \
  && echo $srcdir'/base64.m4:68: Testing block of lines to Base64 and back'
echo base64.m4:68 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/dumps-data output
chmod +w output
recode /../64 output
recode /64../ output
diff $at_srcdir/dumps-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s46)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 46"
       ;;
  esac
  at_test_count=46
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c47(

rm -rf stdout stderr
# Snippet )c47)
  echo quoted.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines from Quoted Printable'
    echo $at_n "     $at_c"
  fi
  echo $at_n "47. $srcdir/quoted.m4:3       $at_c"
  (
# Snippet (s47(

# The test group starts at `quoted.m4:3'.  An error occurred while
# testing block of lines from Quoted Printable.

test -n "$at_verbose" \
  && echo $srcdir'/quoted.m4:24: Testing block of lines from Quoted Printable'
echo quoted.m4:24 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode qp..x1 < $at_srcdir/quoted-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x44, 0x65, 0x61, 0x72, 0x20, 0xDE, 0x6F, 0x72, 0x76, 0x61, 0x72, 0x64,
0xF0, 0x75, 0x72, 0x2C, 0x0A, 0x0A, 0xAB, 0x20, 0x4F, 0xF9, 0x20, 0x71,
0x75, 0x27, 0x69, 0x6C, 0x20, 0x72, 0xE9, 0x73, 0x69, 0x64, 0x65, 0x2C,
0x20, 0xE0, 0x20, 0x4E, 0xEE, 0x6D, 0x65, 0x73, 0x20, 0x6F, 0x75, 0x20,
0x6D, 0xEA, 0x6D, 0x65, 0x20, 0x43, 0x61, 0x70, 0x68, 0x61, 0x72, 0x6E,
0x61, 0xFC, 0x6D, 0x2C, 0x20, 0x74, 0x6F, 0x75, 0x74, 0x20, 0x46, 0x72,
0x61, 0x6E, 0xE7, 0x61, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x73, 0x63, 0x72,
0x69, 0x74, 0x0A, 0x61, 0x75, 0x20, 0x72, 0xF4, 0x6C, 0x65, 0x20, 0x70,
0x61, 0x79, 0x65, 0x72, 0x61, 0x20, 0x73, 0x6F, 0x6E, 0x20, 0x64, 0xFB,
0x20, 0x64, 0xE8, 0x73, 0x20, 0x61, 0x76, 0x61, 0x6E, 0x74, 0x20, 0x4E,
0x6F, 0xEB, 0x6C, 0x2C, 0x20, 0x71, 0x75, 0x27, 0x69, 0x6C, 0x20, 0x73,
0x6F, 0x69, 0x74, 0x20, 0x6E, 0x61, 0xEF, 0x66, 0x20, 0x6F, 0x75, 0x20,
0x72, 0xE2, 0x6C, 0x65, 0x75, 0x72, 0x2E, 0x20, 0xBB, 0x0A, 0x49, 0x6E,
0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74, 0x65, 0x20, 0x6C, 0x61, 0x73,
0x74, 0x20, 0x6C, 0x69, 0x6E, 0x65
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s47)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 47"
       ;;
  esac
  at_test_count=47
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c48(

rm -rf output stdout stderr
# Snippet )c48)
  echo quoted.m4:28 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines from Quoted Printable and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "48. $srcdir/quoted.m4:28      $at_c"
  (
# Snippet (s48(

# The test group starts at `quoted.m4:28'.  An error occurred while
# testing block of lines from Quoted Printable and back.

test -n "$at_verbose" \
  && echo $srcdir'/quoted.m4:39: Testing block of lines from Quoted Printable and back'
echo quoted.m4:39 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/quoted-data output
chmod +w output
recode qp..x1 output
recode x1..qp output
diff $at_srcdir/quoted-data output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s48)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 48"
       ;;
  esac
  at_test_count=48
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf output stdout stderr
  fi
fi

echo
echo 'Individual charsets.'
echo

# FIXME: tests for atarist, next, ebcdic, tables, applemac, ibmpc iconqnx,
# cdcnos, bangbang, ascii, flat, html, latex, texinfo, texte and utf16.

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c49(

rm -rf expout example transcript stdout stderr expout
# Snippet )c49)
  echo african.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing Bambara'
    echo $at_n "     $at_c"
  fi
  echo $at_n "49. $srcdir/african.m4:3      $at_c"
  (
# Snippet (s49(

# The test group starts at `african.m4:3'.  An error occurred while
# testing Bambara.

cat <<'EOF' >example
N ye n ka nsiirin nin da Amadu Tara la.  Jamanatigi d=F2 tun b=E8 yen muso
k=F2n=F2nt=F2 de tun b=E8 a f=E8.  Muso k=F2n=F2nt=F2 b=E8=E8 ye denk=E8 ke=
len kelen
wolo a ye.  A denk=E8 kelen kelen b=E8=E8 fana t=F2g=F2 ye ko Amadu.  Amadu
ninw, u ba t=F2g=F2 de tun b=E8 da u kan ka u b=F2 ny=F2g=F2n na.  Amadu b=
=E8=E8
ncinin tun ye denk=E8 ninw b=E8=E8 la d=F2g=F2nin o de tun ye Amadu Tara ye.
O tun ye jamanatigi nin ka taramuso den ye.
EOF

cat <<'EOF' >transcript
TiB5ZSBuIGthIG5zaWlyaW4gbmluIGRhIEFtYWR1IFRhcmEgbGEuICBKYW1hbmF0aWdpIGRvYCB0
dW4gYmVgIHllbiBtdXNvCmtvYG5vYG50b2AgZGUgdHVuIGJlYCBhIGZlYC4gIE11c28ga29gbm9g
bnRvYCBiZWBlYCB5ZSBkZW5rZWAga2VsZW4ga2VsZW4Kd29sbyBhIHllLiAgQSBkZW5rZWAga2Vs
ZW4ga2VsZW4gYmVgZWAgZmFuYSB0b2Bnb2AgeWUga28gQW1hZHUuICBBbWFkdQpuaW53LCB1IGJh
IHRvYGdvYCBkZSB0dW4gYmVgIGRhIHUga2FuIGthIHUgYm9gIG55b2Bnb2BuIG5hLiAgQW1hZHUg
YmVgZWAKbmNpbmluIHR1biB5ZSBkZW5rZWAgbmludyBiZWBlYCBsYSBkb2Bnb2BuaW4gbyBkZSB0
dW4geWUgQW1hZHUgVGFyYSB5ZS4KTyB0dW4geWUgamFtYW5hdGlnaSBuaW4ga2EgdGFyYW11c28g
ZGVuIHllLgo=
EOF

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:31: Testing Bambara'
echo african.m4:31 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp transcript expout
recode bambara/qp/cl..t-bambara/64 < example

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:36: Testing Bambara'
echo african.m4:36 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp example expout
recode t-bambara/64/cl..bambara/qp < transcript

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s49)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 49"
       ;;
  esac
  at_test_count=49
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expout example transcript stdout stderr expout
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c50(

rm -rf expout example transcript stdout stderr expout
# Snippet )c50)
  echo african.m4:40 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing Peul Fulfulde'
    echo $at_n "     $at_c"
  fi
  echo $at_n "50. $srcdir/african.m4:40     $at_c"
  (
# Snippet (s50(

# The test group starts at `african.m4:40'.  An error occurred while
# testing Peul Fulfulde.

cat <<'EOF' >example
Woni =B2on haa =B1ooyi.  Oya mar=B2o jiwo kaanaro on maayi.  Suka no
ton no wi=BDee Buubu Yee=B1e, on suka e nder sukaa=B1e aduna on alaa
bur=B2o mo labeede.  On suka yahi safaari, o woni ton haa nee=B1i ---
wa duu=B1i sappo o ko fawi! --- Yumma makko maraa =B1i=B2=B2o
go=BDo si wonaa kanko.
EOF

cat <<'EOF' >transcript
V29uaSBkW29uIGhhYSBiW29veWkuICBPeWEgbWFyZFtvIGppd28ga2FhbmFybyBvbiBtYWF5aS4g
IFN1a2Egbm8KdG9uIG5vIHdpP15lZSBCdXVidSBZZWViW2UsIG9uIHN1a2EgZSBuZGVyIHN1a2Fh
YltlIGFkdW5hIG9uIGFsYWEKYnVyZFtvIG1vIGxhYmVlZGUuICBPbiBzdWthIHlhaGkgc2FmYWFy
aSwgbyB3b25pIHRvbiBoYWEgbmVlYltpIC0tLQp3YSBkdXViW2kgc2FwcG8gbyBrbyBmYXdpISAt
LS0gWXVtbWEgbWFra28gbWFyYWEgYltpZFtkW28KZ28/Xm8gc2kgd29uYWEga2Fua28uCg==
EOF

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:62: Testing Peul Fulfulde'
echo african.m4:62 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp transcript expout
recode fulfulde/qp/cl..t-fulfulde/64 < example

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:67: Testing Peul Fulfulde'
echo african.m4:67 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp example expout
recode t-fulfulde/64/cl..fulfulde/qp < transcript

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s50)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 50"
       ;;
  esac
  at_test_count=50
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expout example transcript stdout stderr expout
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c51(

rm -rf expout example transcript stdout stderr expout
# Snippet )c51)
  echo african.m4:71 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing Lingala'
    echo $at_n "     $at_c"
  fi
  echo $at_n "51. $srcdir/african.m4:71     $at_c"
  (
# Snippet (s51(

# The test group starts at `african.m4:71'.  An error occurred while
# testing Lingala.

cat <<'EOF' >example
Mob=E1li m=B6k=B6, azal=E1k=ED s=E9 y=E9m=B6k=B6 n=E1 bil=B6k=F8 m=EDngi.
Mok=F8l=F8 m=B6k=B6 alob=ED: t=EDk=E1 n=E1k=F0nd=F0 koluka mw=E3s=ED.  Ak=
=F0=ED.
At=E1mb=F3l=ED k=E1 k=E1 k=E1, ak=F3m=ED namb=F3ka m=B6k=B6, ak=FAt=ED w=E2=
n=E1 Ntaba.
Ntaba at=FAn=ED y=FD: ndeko, =F5kok=F0nd=F0 w=E1pi?  Moto alob=ED: n=E3kok=
=F0nd=F0
koluka mw=E3si yakob=E1la nay=E9.  Ntaba alob=ED: zil=E1 ng=E1=ED t=F3k=F0n=
d=F0
el=F8ng=B6.
EOF

cat <<'EOF' >transcript
TW9iYVwnbGkgbW9bJ2tvWycsIGF6YWxhXCdraVwnIHNlXCcgeWVcJ21vWydrb1snIG5hXCcgYmls
b1sna29bIG1pXCduZ2kuCk1va29bbG9bIG1vWydrb1snIGFsb2JpXCc6IHRpXCdrYVwnIG5hXCdr
ZVtuZGVbIGtvbHVrYSBtd2FcdnNpXCcuICBBa2VbaVwnLgpBdGFcJ21ib1wnbGlcJyBrYVwnIGth
XCcga2FcJywgYWtvXCdtaVwnIG5hbWJvXCdrYSBtb1sna29bJywgYWt1XCd0aVwnIHdhXm5hXCcg
TnRhYmEuCk50YWJhIGF0dVwnbmlcJyB5ZVx2OiBuZGVrbywgb1x2a29rZVtuZGVbIHdhXCdwaT8g
IE1vdG8gYWxvYmlcJzogbmFcdmtva2VbbmRlWwprb2x1a2EgbXdhXHZzaSB5YWtvYmFcJ2xhIG5h
eWVcJy4gIE50YWJhIGFsb2JpXCc6IHppbGFcJyBuZ2FcJ2lcJyB0b1wna2VbbmRlWwplbG9bbmdv
WycuCg==
EOF

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:101: Testing Lingala'
echo african.m4:101 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp transcript expout
recode lingala/qp/cl..t-lingala/64 < example

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:106: Testing Lingala'
echo african.m4:106 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp example expout
recode t-lingala/64/cl..lingala/qp < transcript

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s51)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 51"
       ;;
  esac
  at_test_count=51
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expout example transcript stdout stderr expout
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c52(

rm -rf expout example transcript stdout stderr expout
# Snippet )c52)
  echo african.m4:110 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing Sango'
    echo $at_n "     $at_c"
  fi
  echo $at_n "52. $srcdir/african.m4:110    $at_c"
  (
# Snippet (s52(

# The test group starts at `african.m4:110'.  An error occurred while
# testing Sango.

cat <<'EOF' >example
M=E2ley=F6mb=F6 ayeke mb=EAn=EE wakua t=EE let=E4a.  Lo yeke zo s=F4 lo y=
=EA kua t=EE
lo m=EEngi.  Azo t=EE y=E2 t=EE vaka s=F4 s=EF lo yeke l=E4ng=F6 da=E4 s=F4=
 ay=EA
t=EBn=EB t=EE lo m=EEngi ngbanga t=EE nz=F6n=EE dut=EF t=EE lo na y=E2ng=E2=
da t=EE
lo na =E2s=EBw=E4 t=EE lo.
EOF

cat <<'EOF' >transcript
TWFebGV5byJtYm8iIGF5ZWtlIG1iZV5uaV4gd2FrdWEgdGleIGxldGEiYS4gIExvIHlla2Ugem8g
c29eIGxvIHllXiBrdWEgdGleCmxvIG1pXm5naS4gIEF6byB0aV4geWFeIHRpXiB2YWthIHNvXiBz
aSIgbG8geWVrZSBsYSJuZ28iIGRhYSIgc29eIGF5ZV4KdGUibmUiIHRpXiBsbyBtaV5uZ2kgbmdi
YW5nYSB0aV4gbnpvIm5pXiBkdXRpIiB0aV4gbG8gbmEgeWFebmdhXmRhIHRpXgpsbyBuYSBhXnNl
IndhIiB0aV4gbG8uCg==
EOF

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:134: Testing Sango'
echo african.m4:134 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp transcript expout
recode sango/qp/cl..t-sango/64 < example

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:139: Testing Sango'
echo african.m4:139 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp example expout
recode t-sango/64/cl..sango/qp < transcript

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s52)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 52"
       ;;
  esac
  at_test_count=52
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expout example transcript stdout stderr expout
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c53(

rm -rf expout example transcript stdout stderr expout
# Snippet )c53)
  echo african.m4:143 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing Wolof'
    echo $at_n "     $at_c"
  fi
  echo $at_n "53. $srcdir/african.m4:143    $at_c"
  (
# Snippet (s53(

# The test group starts at `african.m4:143'.  An error occurred while
# testing Wolof.

cat <<'EOF' >example
Ca 1965 ba leegi, Suwaahili mooy l=E0kk r=E9=E9wum Tansani.  L=E0kk woowu
la=BAuy j=E0ngalee ci daara yu ndaw yi ag yu yem yi.  Ci moom la =BAuy
jottalee xabaar yi =BAuy wax ag yi =BAuy bind.
EOF

cat <<'EOF' >transcript
Q2EgMTk2NSBiYSBsZWVnaSwgU3V3YWFoaWxpIG1vb3kgbGFga2sgcmVcJ2VcJ3d1bSBUYW5zYW5p
LiAgTGFga2sgd29vd3UKbGFuXnV5IGphYG5nYWxlZSBjaSBkYWFyYSB5dSBuZGF3IHlpIGFnIHl1
IHllbSB5aS4gIENpIG1vb20gbGEgbl51eQpqb3R0YWxlZSB4YWJhYXIgeWkgbl51eSB3YXggYWcg
eWkgbl51eSBiaW5kLgo=
EOF

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:162: Testing Wolof'
echo african.m4:162 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp transcript expout
recode wolof/qp/cl..t-wolof/64 < example

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/african.m4:167: Testing Wolof'
echo african.m4:167 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
cp example expout
recode t-wolof/64/cl..wolof/qp < transcript

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  $at_diff expout stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s53)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 53"
       ;;
  esac
  at_test_count=53
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf expout example transcript stdout stderr expout
  fi
fi

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c54(

rm -rf stdout stderr
# Snippet )c54)
  echo combine.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing that combine does not crash'
    echo $at_n "     $at_c"
  fi
  echo $at_n "54. $srcdir/combine.m4:3      $at_c"
  (
# Snippet (s54(

# The test group starts at `combine.m4:3'.  An error occurred while
# testing that combine does not crash.

test -n "$at_verbose" \
  && echo $srcdir'/combine.m4:6: Testing that combine does not crash'
echo combine.m4:6 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode co..l1 < /dev/null
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s54)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 54"
       ;;
  esac
  at_test_count=54
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr
  fi
fi

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c55(

rm -rf stdout stderr
# Snippet )c55)
  echo debug.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing testing and counting'
    echo $at_n "     $at_c"
  fi
  echo $at_n "55. $srcdir/debug.m4:3        $at_c"
  (
# Snippet (s55(

# The test group starts at `debug.m4:3'.  An error occurred while
# testing testing and counting.

test -n "$at_verbose" \
  && echo $srcdir'/debug.m4:11: Testing testing and counting'
echo debug.m4:11 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode test7..x,us..count < /dev/null
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 11  000A LF   117  0020 SP   127  002C ,    152  0030 0     24  0031 1
 24  0032 2     24  0033 3     24  0034 4     24  0035 5     24  0036 6
 24  0037 7      8  0038 8      8  0039 9      8  0041 A      8  0042 B
  8  0043 C      8  0044 D      8  0045 E      8  0046 F    128  0078 x
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/debug.m4:18: Testing testing and counting'
echo debug.m4:18 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode test8..x,us..count < /dev/null
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 22  000A LF   234  0020 SP   255  002C ,    288  0030 0     32  0031 1
 32  0032 2     32  0033 3     32  0034 4     32  0035 5     32  0036 6
 32  0037 7     32  0038 8     32  0039 9     32  0041 A     32  0042 B
 32  0043 C     32  0044 D     32  0045 E     32  0046 F    256  0078 x
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/debug.m4:26: Testing testing and counting'
echo debug.m4:26 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode test15..x2,us..count < /dev/null
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 8064  000A LF   56445  0020 SP   64508  002C ,    80765  0030 0
16256  0031 1    16256  0032 2    16256  0033 3    16256  0034 4
16256  0035 5    16256  0036 6    16256  0037 7    16256  0038 8
16256  0039 9    16256  0041 A    16256  0042 B    16000  0043 C
14975  0044 D    15999  0045 E    15990  0046 F    64509  0078 x
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

test -n "$at_verbose" \
  && echo $srcdir'/debug.m4:34: Testing testing and counting'
echo debug.m4:34 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode test16..x2,us..count < /dev/null
test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n " 8192  000A LF   57344  0020 SP   65535  002C ,    81920  0030 0
16384  0031 1    16384  0032 2    16384  0033 3    16384  0034 4
16384  0035 5    16384  0036 6    16384  0037 7    16384  0038 8
16384  0039 9    16384  0041 A    16384  0042 B    16384  0043 C
16384  0044 D    16384  0045 E    16384  0046 F    65536  0078 x
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s55)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 55"
       ;;
  esac
  at_test_count=55
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr
  fi
fi

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c56(

rm -rf stdout stderr
# Snippet )c56)
  echo utf7.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines from UTF-7'
    echo $at_n "     $at_c"
  fi
  echo $at_n "56. $srcdir/utf7.m4:3         $at_c"
  (
# Snippet (s56(

# The test group starts at `utf7.m4:3'.  An error occurred while
# testing single lines from UTF-7.

test -n "$at_verbose" \
  && echo $srcdir'/utf7.m4:20: Testing single lines from UTF-7'
echo utf7.m4:20 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo "$line" | recode u7/cl..u6/x2
done < $at_srcdir/utf7-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0xFEFF, 0x000A
0xFEFF, 0x0041, 0x2262, 0x0391, 0x002E, 0x000A
0xFEFF, 0x0048, 0x0069, 0x0020, 0x004D, 0x006F, 0x006D, 0x0020,
0x263A, 0x0021, 0x000A
0xFEFF, 0x65E5, 0x672C, 0x8A9E, 0x000A
0xFEFF, 0x0049, 0x0074, 0x0065, 0x006D, 0x0020, 0x0033, 0x0020,
0x0069, 0x0073, 0x0020, 0x00A3, 0x0031, 0x002E, 0x000A
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s56)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 56"
       ;;
  esac
  at_test_count=56
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c57(

rm -rf input output stdout stderr
# Snippet )c57)
  echo utf7.m4:24 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing single lines from UTF-7 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "57. $srcdir/utf7.m4:24        $at_c"
  (
# Snippet (s57(

# The test group starts at `utf7.m4:24'.  An error occurred while
# testing single lines from UTF-7 and back.

test -n "$at_verbose" \
  && echo $srcdir'/utf7.m4:37: Testing single lines from UTF-7 and back'
echo utf7.m4:37 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
while read line; do
  echo "$line" > input
  echo "$line" > output
  recode u7..u6/x2 output
  recode u6/x2..u7 output
  diff input output
done < $at_srcdir/utf7-data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s57)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 57"
       ;;
  esac
  at_test_count=57
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c58(

rm -rf stdout stderr
# Snippet )c58)
  echo utf8.m4:3 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to UTF-8'
    echo $at_n "     $at_c"
  fi
  echo $at_n "58. $srcdir/utf8.m4:3         $at_c"
  (
# Snippet (s58(

# The test group starts at `utf8.m4:3'.  An error occurred while
# testing block of lines to UTF-8.

test -n "$at_verbose" \
  && echo $srcdir'/utf8.m4:25: Testing block of lines to UTF-8'
echo utf8.m4:25 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
recode l1/qp..u8/x < $at_srcdir/quoted-data

test $? = 0 || exit 1
test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  echo $at_n "0x44, 0x65, 0x61, 0x72, 0x20, 0xC3, 0x9E, 0x6F, 0x72, 0x76, 0x61, 0x72,
0x64, 0xC3, 0xB0, 0x75, 0x72, 0x2C, 0x0A, 0x0A, 0xC2, 0xAB, 0x20, 0x4F,
0xC3, 0xB9, 0x20, 0x71, 0x75, 0x27, 0x69, 0x6C, 0x20, 0x72, 0xC3, 0xA9,
0x73, 0x69, 0x64, 0x65, 0x2C, 0x20, 0xC3, 0xA0, 0x20, 0x4E, 0xC3, 0xAE,
0x6D, 0x65, 0x73, 0x20, 0x6F, 0x75, 0x20, 0x6D, 0xC3, 0xAA, 0x6D, 0x65,
0x20, 0x43, 0x61, 0x70, 0x68, 0x61, 0x72, 0x6E, 0x61, 0xC3, 0xBC, 0x6D,
0x2C, 0x20, 0x74, 0x6F, 0x75, 0x74, 0x20, 0x46, 0x72, 0x61, 0x6E, 0xC3,
0xA7, 0x61, 0x69, 0x73, 0x20, 0x69, 0x6E, 0x73, 0x63, 0x72, 0x69, 0x74,
0x0A, 0x61, 0x75, 0x20, 0x72, 0xC3, 0xB4, 0x6C, 0x65, 0x20, 0x70, 0x61,
0x79, 0x65, 0x72, 0x61, 0x20, 0x73, 0x6F, 0x6E, 0x20, 0x64, 0xC3, 0xBB,
0x20, 0x64, 0xC3, 0xA8, 0x73, 0x20, 0x61, 0x76, 0x61, 0x6E, 0x74, 0x20,
0x4E, 0x6F, 0xC3, 0xAB, 0x6C, 0x2C, 0x20, 0x71, 0x75, 0x27, 0x69, 0x6C,
0x20, 0x73, 0x6F, 0x69, 0x74, 0x20, 0x6E, 0x61, 0xC3, 0xAF, 0x66, 0x20,
0x6F, 0x75, 0x20, 0x72, 0xC3, 0xA2, 0x6C, 0x65, 0x75, 0x72, 0x2E, 0x20,
0xC2, 0xBB, 0x0A, 0x49, 0x6E, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x74,
0x65, 0x20, 0x6C, 0x61, 0x73, 0x74, 0x20, 0x6C, 0x69, 0x6E, 0x65
$at_c" | $at_diff - stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s58)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 58"
       ;;
  esac
  at_test_count=58
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c59(

rm -rf input output stdout stderr
# Snippet )c59)
  echo utf8.m4:29 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing block of lines to UTF-8 and back'
    echo $at_n "     $at_c"
  fi
  echo $at_n "59. $srcdir/utf8.m4:29        $at_c"
  (
# Snippet (s59(

# The test group starts at `utf8.m4:29'.  An error occurred while
# testing block of lines to UTF-8 and back.

test -n "$at_verbose" \
  && echo $srcdir'/utf8.m4:41: Testing block of lines to UTF-8 and back'
echo utf8.m4:41 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_srcdir/quoted-data input
cp $at_srcdir/quoted-data output
chmod +w output
recode l1/qp..u8 output
recode u8..l1/qp output
diff input output
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s59)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 59"
       ;;
  esac
  at_test_count=59
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf input output stdout stderr
  fi
fi

echo
echo 'Inter-step mechanics.'
echo

#							-*- shell-script -*-

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c60(

rm -rf data stdout stderr
# Snippet )c60)
  echo methods.m4:24 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:texte through memory while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "60. $srcdir/methods.m4:24     $at_c"
  (
# Snippet (s60(

# The test group starts at `methods.m4:24'.  An error occurred while
# testing texte:texte through memory while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:24: Testing texte:texte through memory while filtering'
echo methods.m4:24 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=memory < $at_top_srcdir/COPYING texte..texte \
| recode --quiet --force --sequence=memory texte..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s60)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 60"
       ;;
  esac
  at_test_count=60
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c61(

rm -rf data stdout stderr
# Snippet )c61)
  echo methods.m4:27 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:texte through memory while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "61. $srcdir/methods.m4:27     $at_c"
  (
# Snippet (s61(

# The test group starts at `methods.m4:27'.  An error occurred while
# testing texte:texte through memory while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:27: Testing texte:texte through memory while squashing'
echo methods.m4:27 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=memory texte..texte data
recode --quiet --force --sequence=memory texte..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s61)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 61"
       ;;
  esac
  at_test_count=61
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c62(

rm -rf data stdout stderr
# Snippet )c62)
  echo methods.m4:30 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:texte through files while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "62. $srcdir/methods.m4:30     $at_c"
  (
# Snippet (s62(

# The test group starts at `methods.m4:30'.  An error occurred while
# testing texte:texte through files while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:30: Testing texte:texte through files while filtering'
echo methods.m4:30 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=files < $at_top_srcdir/COPYING texte..texte \
| recode --quiet --force --sequence=files texte..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s62)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 62"
       ;;
  esac
  at_test_count=62
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c63(

rm -rf data stdout stderr
# Snippet )c63)
  echo methods.m4:33 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:texte through files while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "63. $srcdir/methods.m4:33     $at_c"
  (
# Snippet (s63(

# The test group starts at `methods.m4:33'.  An error occurred while
# testing texte:texte through files while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:33: Testing texte:texte through files while squashing'
echo methods.m4:33 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=files texte..texte data
recode --quiet --force --sequence=files texte..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s63)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 63"
       ;;
  esac
  at_test_count=63
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c64(

rm -rf data stdout stderr
# Snippet )c64)
  echo methods.m4:36 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:texte through pipe while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "64. $srcdir/methods.m4:36     $at_c"
  (
# Snippet (s64(

# The test group starts at `methods.m4:36'.  An error occurred while
# testing texte:texte through pipe while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:36: Testing texte:texte through pipe while filtering'
echo methods.m4:36 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=pipe < $at_top_srcdir/COPYING texte..texte \
| recode --quiet --force --sequence=pipe texte..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s64)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 64"
       ;;
  esac
  at_test_count=64
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c65(

rm -rf data stdout stderr
# Snippet )c65)
  echo methods.m4:39 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:texte through pipe while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "65. $srcdir/methods.m4:39     $at_c"
  (
# Snippet (s65(

# The test group starts at `methods.m4:39'.  An error occurred while
# testing texte:texte through pipe while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:39: Testing texte:texte through pipe while squashing'
echo methods.m4:39 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=pipe texte..texte data
recode --quiet --force --sequence=pipe texte..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s65)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 65"
       ;;
  esac
  at_test_count=65
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c66(

rm -rf data stdout stderr
# Snippet )c66)
  echo methods.m4:42 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:latin1 through memory while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "66. $srcdir/methods.m4:42     $at_c"
  (
# Snippet (s66(

# The test group starts at `methods.m4:42'.  An error occurred while
# testing texte:latin1 through memory while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:42: Testing texte:latin1 through memory while filtering'
echo methods.m4:42 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=memory < $at_top_srcdir/COPYING texte..latin1 \
| recode --quiet --force --sequence=memory latin1..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s66)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 66"
       ;;
  esac
  at_test_count=66
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c67(

rm -rf data stdout stderr
# Snippet )c67)
  echo methods.m4:45 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:latin1 through memory while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "67. $srcdir/methods.m4:45     $at_c"
  (
# Snippet (s67(

# The test group starts at `methods.m4:45'.  An error occurred while
# testing texte:latin1 through memory while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:45: Testing texte:latin1 through memory while squashing'
echo methods.m4:45 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=memory texte..latin1 data
recode --quiet --force --sequence=memory latin1..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s67)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 67"
       ;;
  esac
  at_test_count=67
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c68(

rm -rf data stdout stderr
# Snippet )c68)
  echo methods.m4:48 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:latin1 through files while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "68. $srcdir/methods.m4:48     $at_c"
  (
# Snippet (s68(

# The test group starts at `methods.m4:48'.  An error occurred while
# testing texte:latin1 through files while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:48: Testing texte:latin1 through files while filtering'
echo methods.m4:48 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=files < $at_top_srcdir/COPYING texte..latin1 \
| recode --quiet --force --sequence=files latin1..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s68)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 68"
       ;;
  esac
  at_test_count=68
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c69(

rm -rf data stdout stderr
# Snippet )c69)
  echo methods.m4:51 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:latin1 through files while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "69. $srcdir/methods.m4:51     $at_c"
  (
# Snippet (s69(

# The test group starts at `methods.m4:51'.  An error occurred while
# testing texte:latin1 through files while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:51: Testing texte:latin1 through files while squashing'
echo methods.m4:51 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=files texte..latin1 data
recode --quiet --force --sequence=files latin1..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s69)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 69"
       ;;
  esac
  at_test_count=69
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c70(

rm -rf data stdout stderr
# Snippet )c70)
  echo methods.m4:54 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:latin1 through pipe while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "70. $srcdir/methods.m4:54     $at_c"
  (
# Snippet (s70(

# The test group starts at `methods.m4:54'.  An error occurred while
# testing texte:latin1 through pipe while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:54: Testing texte:latin1 through pipe while filtering'
echo methods.m4:54 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=pipe < $at_top_srcdir/COPYING texte..latin1 \
| recode --quiet --force --sequence=pipe latin1..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s70)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 70"
       ;;
  esac
  at_test_count=70
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c71(

rm -rf data stdout stderr
# Snippet )c71)
  echo methods.m4:57 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:latin1 through pipe while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "71. $srcdir/methods.m4:57     $at_c"
  (
# Snippet (s71(

# The test group starts at `methods.m4:57'.  An error occurred while
# testing texte:latin1 through pipe while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:57: Testing texte:latin1 through pipe while squashing'
echo methods.m4:57 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=pipe texte..latin1 data
recode --quiet --force --sequence=pipe latin1..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s71)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 71"
       ;;
  esac
  at_test_count=71
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c72(

rm -rf data stdout stderr
# Snippet )c72)
  echo methods.m4:60 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:bangbang through memory while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "72. $srcdir/methods.m4:60     $at_c"
  (
# Snippet (s72(

# The test group starts at `methods.m4:60'.  An error occurred while
# testing texte:bangbang through memory while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:60: Testing texte:bangbang through memory while filtering'
echo methods.m4:60 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=memory < $at_top_srcdir/COPYING texte..bangbang \
| recode --quiet --force --sequence=memory bangbang..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s72)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 72"
       ;;
  esac
  at_test_count=72
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c73(

rm -rf data stdout stderr
# Snippet )c73)
  echo methods.m4:63 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:bangbang through memory while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "73. $srcdir/methods.m4:63     $at_c"
  (
# Snippet (s73(

# The test group starts at `methods.m4:63'.  An error occurred while
# testing texte:bangbang through memory while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:63: Testing texte:bangbang through memory while squashing'
echo methods.m4:63 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=memory texte..bangbang data
recode --quiet --force --sequence=memory bangbang..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s73)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 73"
       ;;
  esac
  at_test_count=73
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c74(

rm -rf data stdout stderr
# Snippet )c74)
  echo methods.m4:66 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:bangbang through files while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "74. $srcdir/methods.m4:66     $at_c"
  (
# Snippet (s74(

# The test group starts at `methods.m4:66'.  An error occurred while
# testing texte:bangbang through files while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:66: Testing texte:bangbang through files while filtering'
echo methods.m4:66 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=files < $at_top_srcdir/COPYING texte..bangbang \
| recode --quiet --force --sequence=files bangbang..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s74)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 74"
       ;;
  esac
  at_test_count=74
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c75(

rm -rf data stdout stderr
# Snippet )c75)
  echo methods.m4:69 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:bangbang through files while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "75. $srcdir/methods.m4:69     $at_c"
  (
# Snippet (s75(

# The test group starts at `methods.m4:69'.  An error occurred while
# testing texte:bangbang through files while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:69: Testing texte:bangbang through files while squashing'
echo methods.m4:69 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=files texte..bangbang data
recode --quiet --force --sequence=files bangbang..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s75)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 75"
       ;;
  esac
  at_test_count=75
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c76(

rm -rf data stdout stderr
# Snippet )c76)
  echo methods.m4:72 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:bangbang through pipe while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "76. $srcdir/methods.m4:72     $at_c"
  (
# Snippet (s76(

# The test group starts at `methods.m4:72'.  An error occurred while
# testing texte:bangbang through pipe while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:72: Testing texte:bangbang through pipe while filtering'
echo methods.m4:72 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=pipe < $at_top_srcdir/COPYING texte..bangbang \
| recode --quiet --force --sequence=pipe bangbang..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s76)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 76"
       ;;
  esac
  at_test_count=76
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c77(

rm -rf data stdout stderr
# Snippet )c77)
  echo methods.m4:75 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:bangbang through pipe while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "77. $srcdir/methods.m4:75     $at_c"
  (
# Snippet (s77(

# The test group starts at `methods.m4:75'.  An error occurred while
# testing texte:bangbang through pipe while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:75: Testing texte:bangbang through pipe while squashing'
echo methods.m4:75 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=pipe texte..bangbang data
recode --quiet --force --sequence=pipe bangbang..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s77)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 77"
       ;;
  esac
  at_test_count=77
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c78(

rm -rf data stdout stderr
# Snippet )c78)
  echo methods.m4:78 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:ibmpc through memory while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "78. $srcdir/methods.m4:78     $at_c"
  (
# Snippet (s78(

# The test group starts at `methods.m4:78'.  An error occurred while
# testing texte:ibmpc through memory while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:78: Testing texte:ibmpc through memory while filtering'
echo methods.m4:78 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=memory < $at_top_srcdir/COPYING texte..ibmpc \
| recode --quiet --force --sequence=memory ibmpc..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s78)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 78"
       ;;
  esac
  at_test_count=78
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c79(

rm -rf data stdout stderr
# Snippet )c79)
  echo methods.m4:81 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:ibmpc through memory while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "79. $srcdir/methods.m4:81     $at_c"
  (
# Snippet (s79(

# The test group starts at `methods.m4:81'.  An error occurred while
# testing texte:ibmpc through memory while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:81: Testing texte:ibmpc through memory while squashing'
echo methods.m4:81 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=memory texte..ibmpc data
recode --quiet --force --sequence=memory ibmpc..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s79)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 79"
       ;;
  esac
  at_test_count=79
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c80(

rm -rf data stdout stderr
# Snippet )c80)
  echo methods.m4:84 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:ibmpc through files while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "80. $srcdir/methods.m4:84     $at_c"
  (
# Snippet (s80(

# The test group starts at `methods.m4:84'.  An error occurred while
# testing texte:ibmpc through files while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:84: Testing texte:ibmpc through files while filtering'
echo methods.m4:84 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=files < $at_top_srcdir/COPYING texte..ibmpc \
| recode --quiet --force --sequence=files ibmpc..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s80)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 80"
       ;;
  esac
  at_test_count=80
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c81(

rm -rf data stdout stderr
# Snippet )c81)
  echo methods.m4:87 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:ibmpc through files while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "81. $srcdir/methods.m4:87     $at_c"
  (
# Snippet (s81(

# The test group starts at `methods.m4:87'.  An error occurred while
# testing texte:ibmpc through files while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:87: Testing texte:ibmpc through files while squashing'
echo methods.m4:87 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=files texte..ibmpc data
recode --quiet --force --sequence=files ibmpc..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s81)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 81"
       ;;
  esac
  at_test_count=81
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c82(

rm -rf data stdout stderr
# Snippet )c82)
  echo methods.m4:90 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:ibmpc through pipe while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "82. $srcdir/methods.m4:90     $at_c"
  (
# Snippet (s82(

# The test group starts at `methods.m4:90'.  An error occurred while
# testing texte:ibmpc through pipe while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:90: Testing texte:ibmpc through pipe while filtering'
echo methods.m4:90 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=pipe < $at_top_srcdir/COPYING texte..ibmpc \
| recode --quiet --force --sequence=pipe ibmpc..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s82)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 82"
       ;;
  esac
  at_test_count=82
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c83(

rm -rf data stdout stderr
# Snippet )c83)
  echo methods.m4:93 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:ibmpc through pipe while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "83. $srcdir/methods.m4:93     $at_c"
  (
# Snippet (s83(

# The test group starts at `methods.m4:93'.  An error occurred while
# testing texte:ibmpc through pipe while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:93: Testing texte:ibmpc through pipe while squashing'
echo methods.m4:93 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=pipe texte..ibmpc data
recode --quiet --force --sequence=pipe ibmpc..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s83)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 83"
       ;;
  esac
  at_test_count=83
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c84(

rm -rf data stdout stderr
# Snippet )c84)
  echo methods.m4:96 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:iconqnx through memory while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "84. $srcdir/methods.m4:96     $at_c"
  (
# Snippet (s84(

# The test group starts at `methods.m4:96'.  An error occurred while
# testing texte:iconqnx through memory while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:96: Testing texte:iconqnx through memory while filtering'
echo methods.m4:96 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=memory < $at_top_srcdir/COPYING texte..iconqnx \
| recode --quiet --force --sequence=memory iconqnx..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s84)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 84"
       ;;
  esac
  at_test_count=84
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c85(

rm -rf data stdout stderr
# Snippet )c85)
  echo methods.m4:99 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:iconqnx through memory while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "85. $srcdir/methods.m4:99     $at_c"
  (
# Snippet (s85(

# The test group starts at `methods.m4:99'.  An error occurred while
# testing texte:iconqnx through memory while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:99: Testing texte:iconqnx through memory while squashing'
echo methods.m4:99 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=memory texte..iconqnx data
recode --quiet --force --sequence=memory iconqnx..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s85)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 85"
       ;;
  esac
  at_test_count=85
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c86(

rm -rf data stdout stderr
# Snippet )c86)
  echo methods.m4:102 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:iconqnx through files while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "86. $srcdir/methods.m4:102    $at_c"
  (
# Snippet (s86(

# The test group starts at `methods.m4:102'.  An error occurred while
# testing texte:iconqnx through files while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:102: Testing texte:iconqnx through files while filtering'
echo methods.m4:102 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=files < $at_top_srcdir/COPYING texte..iconqnx \
| recode --quiet --force --sequence=files iconqnx..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s86)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 86"
       ;;
  esac
  at_test_count=86
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c87(

rm -rf data stdout stderr
# Snippet )c87)
  echo methods.m4:105 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:iconqnx through files while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "87. $srcdir/methods.m4:105    $at_c"
  (
# Snippet (s87(

# The test group starts at `methods.m4:105'.  An error occurred while
# testing texte:iconqnx through files while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:105: Testing texte:iconqnx through files while squashing'
echo methods.m4:105 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=files texte..iconqnx data
recode --quiet --force --sequence=files iconqnx..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s87)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 87"
       ;;
  esac
  at_test_count=87
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c88(

rm -rf data stdout stderr
# Snippet )c88)
  echo methods.m4:108 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:iconqnx through pipe while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "88. $srcdir/methods.m4:108    $at_c"
  (
# Snippet (s88(

# The test group starts at `methods.m4:108'.  An error occurred while
# testing texte:iconqnx through pipe while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:108: Testing texte:iconqnx through pipe while filtering'
echo methods.m4:108 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=pipe < $at_top_srcdir/COPYING texte..iconqnx \
| recode --quiet --force --sequence=pipe iconqnx..texte > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s88)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 88"
       ;;
  esac
  at_test_count=88
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c89(

rm -rf data stdout stderr
# Snippet )c89)
  echo methods.m4:111 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing texte:iconqnx through pipe while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "89. $srcdir/methods.m4:111    $at_c"
  (
# Snippet (s89(

# The test group starts at `methods.m4:111'.  An error occurred while
# testing texte:iconqnx through pipe while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:111: Testing texte:iconqnx through pipe while squashing'
echo methods.m4:111 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=pipe texte..iconqnx data
recode --quiet --force --sequence=pipe iconqnx..texte data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s89)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 89"
       ;;
  esac
  at_test_count=89
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c90(

rm -rf data stdout stderr
# Snippet )c90)
  echo methods.m4:114 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing ascii-bs:ebcdic through memory while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "90. $srcdir/methods.m4:114    $at_c"
  (
# Snippet (s90(

# The test group starts at `methods.m4:114'.  An error occurred while
# testing ascii-bs:ebcdic through memory while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:114: Testing ascii-bs:ebcdic through memory while filtering'
echo methods.m4:114 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=memory < $at_top_srcdir/COPYING ascii-bs..ebcdic \
| recode --quiet --force --sequence=memory ebcdic..ascii-bs > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s90)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 90"
       ;;
  esac
  at_test_count=90
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c91(

rm -rf data stdout stderr
# Snippet )c91)
  echo methods.m4:117 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing ascii-bs:ebcdic through memory while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "91. $srcdir/methods.m4:117    $at_c"
  (
# Snippet (s91(

# The test group starts at `methods.m4:117'.  An error occurred while
# testing ascii-bs:ebcdic through memory while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:117: Testing ascii-bs:ebcdic through memory while squashing'
echo methods.m4:117 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=memory ascii-bs..ebcdic data
recode --quiet --force --sequence=memory ebcdic..ascii-bs data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s91)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 91"
       ;;
  esac
  at_test_count=91
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c92(

rm -rf data stdout stderr
# Snippet )c92)
  echo methods.m4:120 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing ascii-bs:ebcdic through files while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "92. $srcdir/methods.m4:120    $at_c"
  (
# Snippet (s92(

# The test group starts at `methods.m4:120'.  An error occurred while
# testing ascii-bs:ebcdic through files while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:120: Testing ascii-bs:ebcdic through files while filtering'
echo methods.m4:120 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=files < $at_top_srcdir/COPYING ascii-bs..ebcdic \
| recode --quiet --force --sequence=files ebcdic..ascii-bs > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s92)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 92"
       ;;
  esac
  at_test_count=92
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c93(

rm -rf data stdout stderr
# Snippet )c93)
  echo methods.m4:123 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing ascii-bs:ebcdic through files while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "93. $srcdir/methods.m4:123    $at_c"
  (
# Snippet (s93(

# The test group starts at `methods.m4:123'.  An error occurred while
# testing ascii-bs:ebcdic through files while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:123: Testing ascii-bs:ebcdic through files while squashing'
echo methods.m4:123 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=files ascii-bs..ebcdic data
recode --quiet --force --sequence=files ebcdic..ascii-bs data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s93)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 93"
       ;;
  esac
  at_test_count=93
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c94(

rm -rf data stdout stderr
# Snippet )c94)
  echo methods.m4:126 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing ascii-bs:ebcdic through pipe while filtering'
    echo $at_n "     $at_c"
  fi
  echo $at_n "94. $srcdir/methods.m4:126    $at_c"
  (
# Snippet (s94(

# The test group starts at `methods.m4:126'.  An error occurred while
# testing ascii-bs:ebcdic through pipe while filtering.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:126: Testing ascii-bs:ebcdic through pipe while filtering'
echo methods.m4:126 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
recode --quiet --force --sequence=pipe < $at_top_srcdir/COPYING ascii-bs..ebcdic \
| recode --quiet --force --sequence=pipe ebcdic..ascii-bs > data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s94)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 94"
       ;;
  esac
  at_test_count=94
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
# Snippet (c95(

rm -rf data stdout stderr
# Snippet )c95)
  echo methods.m4:129 > at-check-line
  if test -n "$at_verbose"; then
    echo 'testing ascii-bs:ebcdic through pipe while squashing'
    echo $at_n "     $at_c"
  fi
  echo $at_n "95. $srcdir/methods.m4:129    $at_c"
  (
# Snippet (s95(

# The test group starts at `methods.m4:129'.  An error occurred while
# testing ascii-bs:ebcdic through pipe while squashing.

test -n "$at_verbose" \
  && echo $srcdir'/methods.m4:129: Testing ascii-bs:ebcdic through pipe while squashing'
echo methods.m4:129 > at-check-line
test -z "$at_no_redirs" && exec 5>&1 6>&2 1>stdout 2>stderr
test -n "$at_tracex" && set -x
set -e
cp $at_top_srcdir/COPYING data
chmod +w data
recode --quiet --force --sequence=pipe ascii-bs..ebcdic data
recode --quiet --force --sequence=pipe ebcdic..ascii-bs data
diff $at_top_srcdir/COPYING data
set +e

test -n "$at_tracex" && set +x
if test -z "$at_no_redirs"; then
  exec 1>&5 2>&6
  test ! -s stdout || exit 1
  test ! -s stderr || exit 1
fi

# Snippet )s95)
  )
  case $? in
    0) echo ok
       ;;
    77) echo "ignored near \``cat at-check-line`'"
        at_ignore_count=`expr $at_ignore_count + 1`
	;;
    *) echo "FAILED near \``cat at-check-line`'"
       at_failed_list="$at_failed_list 95"
       ;;
  esac
  at_test_count=95
  if test -z "$at_stop_on_error" || test -z "$at_failed_list"; then
    rm -rf data stdout stderr
  fi
fi

# Wrap up the testing suite with summary statistics.

rm -f at-check-line
at_fail_count=0
if test -z "$at_failed_list"; then
  if test "$at_ignore_count" = 0; then
    at_banner="All $at_test_count tests were successful"
  else
    at_banner="All $at_test_count tests were successful ($at_ignore_count ignored)"
  fi
else
  echo
  echo $at_n "Writing \`debug-NN.sh' scripts, NN =$at_c"
  for at_group in $at_failed_list; do
    echo $at_n " $at_group$at_c"
    ( echo '#!/bin/sh'
      sed -n "/^# Snippet (1/,/^# Snippet )1/p" atconfig
      test -z "$at_silent" && echo 'at_verbose=1'
      sed -n "/^# Snippet (2/,/^# Snippet )2/p" atconfig
      sed -n "/^# Snippet (3/,/^# Snippet )3/p" $0
      sed -n "/^# Snippet (c$at_group(/,/^# Snippet )c$at_group)/p" $0
      echo 'test -n "$at_verbose" \
        && echo "$0:1: =================================================="'
      sed -n "/^# Snippet (s$at_group(/,/^# Snippet )s$at_group)/p" $0
      echo 'exit 0'
    ) | grep -v '^# Snippet' > debug-$at_group.sh
    chmod +x debug-$at_group.sh
    at_fail_count=`expr $at_fail_count + 1`
  done
  echo ', done'
  if test -n "$at_stop_on_error"; then
    at_banner="ERROR: One of the tests failed, inhibiting subsequent tests"
  else
    at_banner="ERROR: Suite unsuccessful, $at_fail_count of $at_test_count tests failed"
  fi
fi
at_dashes=`echo $at_banner | sed s/./=/g`
echo
echo "$at_dashes"
echo "$at_banner"
echo "$at_dashes"

if test -n "$at_failed_list"; then
  if test -z "$at_silent"; then
    echo
    echo "Now, failed tests will be executed again, with more details..."
    echo
    for at_group in $at_failed_list; do
      ./debug-$at_group.sh
    done
  fi
  exit 1
fi

exit 0
