#! /bin/sh
# Generated from i18n_sjis.at by GNU Autoconf 2.63.
#
# Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
# Free Software Foundation, Inc.
# This test suite is free software; the Free Software Foundation gives
# unlimited permission to copy, distribute and modify it.
## --------------------- ##
## M4sh Initialization.  ##
## --------------------- ##

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

fi




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

as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

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

# Support unset when possible.
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  as_unset=unset
else
  as_unset=false
fi


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

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

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

# Work around bugs in pre-3.0 UWIN ksh.
for as_var in ENV MAIL MAILPATH
do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
done
PS1='$ '
PS2='> '
PS4='+ '

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

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

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


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

# CDPATH.
$as_unset CDPATH


if test "x$CONFIG_SHELL" = x; then
  if (eval ":") 2>/dev/null; then
  as_have_required=yes
else
  as_have_required=no
fi

  if test $as_have_required = yes &&	 (eval ":
(as_func_return () {
  (exit \$1)
}
as_func_success () {
  as_func_return 0
}
as_func_failure () {
  as_func_return 1
}
as_func_ret_success () {
  return 0
}
as_func_ret_failure () {
  return 1
}

exitcode=0
if as_func_success; then
  :
else
  exitcode=1
  echo as_func_success failed.
fi

if as_func_failure; then
  exitcode=1
  echo as_func_failure succeeded.
fi

if as_func_ret_success; then
  :
else
  exitcode=1
  echo as_func_ret_success failed.
fi

if as_func_ret_failure; then
  exitcode=1
  echo as_func_ret_failure succeeded.
fi

if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
  :
else
  exitcode=1
  echo positional parameters were not saved.
fi

test \$exitcode = 0) || { (exit 1); exit 1; }

(
  as_lineno_1=\$LINENO
  as_lineno_2=\$LINENO
  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
") 2> /dev/null; then
  :
else
  as_candidate_shells=
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  case $as_dir in
	 /*)
	   for as_base in sh bash ksh sh5; do
	     as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
	   done;;
       esac
done
IFS=$as_save_IFS


      for as_shell in $as_candidate_shells $SHELL; do
	 # Try only shells that exist, to save several forks.
	 if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		{ ("$as_shell") 2> /dev/null <<\_ASEOF
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in
  *posix*) set -o posix ;;
esac

fi


:
_ASEOF
}; then
  CONFIG_SHELL=$as_shell
	       as_have_required=yes
	       if { "$as_shell" 2> /dev/null <<\_ASEOF
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in
  *posix*) set -o posix ;;
esac

fi


:
(as_func_return () {
  (exit $1)
}
as_func_success () {
  as_func_return 0
}
as_func_failure () {
  as_func_return 1
}
as_func_ret_success () {
  return 0
}
as_func_ret_failure () {
  return 1
}

exitcode=0
if as_func_success; then
  :
else
  exitcode=1
  echo as_func_success failed.
fi

if as_func_failure; then
  exitcode=1
  echo as_func_failure succeeded.
fi

if as_func_ret_success; then
  :
else
  exitcode=1
  echo as_func_ret_success failed.
fi

if as_func_ret_failure; then
  exitcode=1
  echo as_func_ret_failure succeeded.
fi

if ( set x; as_func_ret_success y && test x = "$1" ); then
  :
else
  exitcode=1
  echo positional parameters were not saved.
fi

test $exitcode = 0) || { (exit 1); exit 1; }

(
  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }

_ASEOF
}; then
  break
fi

fi

      done

      if test "x$CONFIG_SHELL" != x; then
  for as_var in BASH_ENV ENV
	do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
	done
	export CONFIG_SHELL
	exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
fi


    if test $as_have_required = no; then
  echo This script requires a shell more modern than all the
      echo shells that I found on your system.  Please install a
      echo modern shell, or manually run the script under such a
      echo shell if you do have one.
      { (exit 1); exit 1; }
fi


fi

fi



(eval "as_func_return () {
  (exit \$1)
}
as_func_success () {
  as_func_return 0
}
as_func_failure () {
  as_func_return 1
}
as_func_ret_success () {
  return 0
}
as_func_ret_failure () {
  return 1
}

exitcode=0
if as_func_success; then
  :
else
  exitcode=1
  echo as_func_success failed.
fi

if as_func_failure; then
  exitcode=1
  echo as_func_failure succeeded.
fi

if as_func_ret_success; then
  :
else
  exitcode=1
  echo as_func_ret_success failed.
fi

if as_func_ret_failure; then
  exitcode=1
  echo as_func_ret_failure succeeded.
fi

if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
  :
else
  exitcode=1
  echo positional parameters were not saved.
fi

test \$exitcode = 0") || {
  echo No shell found that supports shell functions.
  echo Please tell bug-autoconf@gnu.org about your system,
  echo including any error possibly output before this message.
  echo This can help us improve future autoconf versions.
  echo Configuration will now proceed without shell functions.
}



  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {

  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
  # uniformly replaced by the line number.  The first 'sed' inserts a
  # line-number line after each line using $LINENO; the second 'sed'
  # does the real work.  The second script uses 'N' to pair each
  # line-number line with the line containing $LINENO, and appends
  # trailing '-' during substitution so that $LINENO is not a special
  # case at line end.
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
  # scripts with optimization help from Paolo Bonzini.  Blame Lee
  # E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      t loop
      s/-\n.*//
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { { $as_echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
$as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
   { (exit 1); exit 1; }; }

  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensitive to this).
  . "./$as_me.lineno"
  # Exit status is that of the last command.
  exit
}


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

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in
-n*)
  case `echo 'x\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  *)   ECHO_C='\c';;
  esac;;
*)
  ECHO_N='-n';;
esac
if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

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

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

if test -x / >/dev/null 2>&1; then
  as_test_x='test -x'
else
  if ls -dL / >/dev/null 2>&1; then
    as_ls_L_option=L
  else
    as_ls_L_option=
  fi
  as_test_x='
    eval sh -c '\''
      if test -d "$1"; then
	test -d "$1/.";
      else
	case $1 in
	-*)set "./$1";;
	esac;
	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
	???[sx]*):;;*)false;;esac;fi
    '\'' sh
  '
fi
as_executable_p=$as_test_x

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

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





SHELL=${CONFIG_SHELL-/bin/sh}

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


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

# CLI Arguments to pass to the debugging scripts.
at_debug_args=
# -e sets to true
at_errexit_p=false
# Shall we be verbose?  ':' means no, empty means yes.
at_verbose=:
at_quiet=

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

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

# List of the tested programs.
at_tested='cobc'
# List of the all the test groups.
at_groups_all=' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 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 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105'
# As many question marks as there are digits in the last test group number.
# Used to normalize the test group numbers so that `ls' lists them in
# numerical order.
at_format='???'
# Description of all the test groups.
at_help_all="1;user-defined-word.at:1;Program name;;
2;user-defined-word.at:14;Field name;;
3;user-defined-word.at:33;Long field name;;
4;user-defined-word.at:58;Field lookup;;
5;user-defined-word.at:77;Section name;;
6;user-defined-word.at:99;Long section name;;
7;user-defined-word.at:121;Too long section name;;
8;user-defined-word.at:145;Nihongo Filename;;
9;user-defined-word.at:180;Nihongo field name in numeric test msg.;;
10;user-defined-word.at:203;Nihongo field name in BASED test msg.;;
11;user-defined-word.at:224;Nihongo field name in ODO test msg.;;
12;user-defined-word.at:246;Nihongo field name in Subscript test msg.;;
13;user-defined-word.at:268;Nihongo field name in length of ref_mod test msg.;;
14;user-defined-word.at:290;Nihongo field name in offset of ref_mod test msg.;;
15;user-defined-word.at:312;Nihongo field name in length of N_refmod test msg.;;
16;user-defined-word.at:334;Nihongo field name in offset of N_refmod test msg.;;
17;user-defined-word.at:356;Nihongo field name in extaddr test msg.;;
18;user-defined-word.at:384;Nihongo field name in undefined error msg.;;
19;user-defined-word.at:423;Nihongo field name in ambiguous error msg.;;
20;user-defined-word.at:459;Nihongo label name in ambiguous error msg.;;
21;pic-x.at:1;Value clause;;
22;pic-x.at:19;Move;;
23;pic-x.at:38;Move with trunc;;
24;pic-x.at:60;Move ALL with trunc and trimming;;
25;pic-x.at:80;Move with trunc and trimming 1;;
26;pic-x.at:103;Move from field with trunc and trimming 1;;
27;pic-x.at:124;Move with padding;;
28;pic-x.at:143;Move with justify;;
29;pic-x.at:162;Move to alnum EDITED;;
30;pic-x.at:181;Move to alnum EDITED (pic too short);;
31;pic-x.at:203;Move to alnum EDITED (pic too long);;
32;pic-x.at:222;Move to alnum EDITED (No char break);;
33;pic-x.at:241;Move to alnum EDITED (char break & junk chars);;
34;pic-x.at:261;Move group to group in bad alignment;;
35;pic-x.at:286;Redifinition breaking char pos.;;
36;pic-x.at:311;Ref mod(n:);;
37;pic-x.at:330;Ref mod(n:m);;
38;pic-x.at:349;STRING by size;;
39;pic-x.at:372;STRING with delimiter;;
40;pic-x.at:399;STRING with pointer;;
41;pic-x.at:423;INSPECT REPLACING;;
42;pic-x.at:442;INSPECT REPLACING by ZERO;;
43;pic-x.at:461;INSPECT TALLYING;;
44;pic-n.at:1;PIC N Value clause;;
45;pic-n.at:19;PIC N Move;;
46;pic-n.at:38;PIC N Move with trunc;;
47;pic-n.at:60;PIC N Move with padding by full-width SPC;;
48;pic-n.at:79;PIC N Move with justify;;
49;pic-n.at:98;PIC N EDITED w/ VALUE;;
50;pic-n.at:116;INITIALIZE PIC N EDITED;;
51;pic-n.at:136;INITIALIZE PIC N EDITED TO VALUE;;
52;pic-n.at:156;PIC N Move to NATIONAL EDITED;;
53;pic-n.at:175;PIC N Move with half-width alnum conv.;;
54;pic-n.at:194;PIC N Move with half-width kana conv.;;
55;pic-n.at:214;PIC N Ref mod(n:);;
56;pic-n.at:233;PIC N Ref mod(n:m);;
57;pic-n.at:252;PIC N STRING by size;;
58;pic-n.at:275;PIC N STRING with delimiter (causes warn);;
59;pic-n.at:298;PIC N STRING with NATIONAL delimiter;;
60;pic-n.at:321;PIC N STRING with pointer;;
61;pic-n.at:345;PIC N INSPECT REPLACING;;
62;pic-n.at:364;PIC N INSPECT REPLACING by ZERO;;
63;pic-n.at:383;PIC N INSPECT REPLACING by NATIONAL ZERO;;
64;pic-n.at:402;PIC N INSPECT TALLYING;;
65;pic-n.at:422;PIC N Move with half-width dakuten kana.;;
66;pic-n.at:441;PIC N Move with half-width han-dakuten kana.;;
67;program-id.at:1;PROGRAM-ID NATIONAL C89 no warning;;
68;program-id.at:20;PROGRAM-ID NATIONAL C89 warning;;
69;program-id.at:42;PROGRAM-ID NATIONAL C89 ignore;;
70;program-id.at:56;PROGRAM-ID NATIONAL 32 character no over;;
71;program-id.at:71;PROGRAM-ID NATIONAL 32 character over;;
72;error-print.at:1;undefined not message;;
73;error-print.at:24;Encoding alphanumeric name item;;
74;error-print.at:41;Encoding national name item;;
75;error-print.at:58;Decoding national section name;;
76;limits.at:1;Field length limit PIC A/VALID;;
77;limits.at:17;Field length limit PIC A/TOO LONG;;
78;limits.at:35;Field length limit PIC X/VALID;;
79;limits.at:51;Field length limit PIC X/TOO LONG;;
80;limits.at:69;Field length limit PIC B9/VALID;;
81;limits.at:85;Field length limit PIC B9/TOO LONG;;
82;limits.at:103;Field length limit PIC B/VALID;;
83;limits.at:119;Field length limit PIC B/TOO LONG;;
84;limits.at:137;Field length limit PIC BA/VALID;;
85;limits.at:153;Field length limit PIC BA/TOO LONG;;
86;limits.at:171;Field length limit PIC BX/VALID;;
87;limits.at:187;Field length limit PIC BX/TOO LONG;;
88;limits.at:205;Field length limit PIC N/VALID (SJIS);;
89;limits.at:221;Field length limit PIC N/TOO LONG (SJIS);;
90;limits.at:239;Field length limit PIC BN/VALID (SJIS);;
91;limits.at:255;Field length limit PIC BN/TOO LONG (SJIS);;
92;national.at:1;FUNCTION NATIONAL single-byte;;
93;national.at:22;FUNCTION NATIONAL multi-byte;;
94;national.at:43;FUNCTION NATIONAL KIGOU-exclamation;;
95;national.at:64;FUNCTION NATIONAL KIGOU-yen;;
96;national.at:85;FUNCTION NATIONAL KIGOU-plus;;
97;national.at:106;FUNCTION NATIONAL (HanKana w/ Daku-on);;
98;national.at:127;FUNCTION NATIONAL (HanKana w/ Han-daku-on);;
99;national.at:148;N Literal (NO zenakaku conversion);;
100;national.at:173;NC Literal (NO zenakaku conversion);;
101;national.at:198;ND Literal (NO zenakaku conversion);;
102;national.at:223;NX Literal;;
103;mb-space.at:1;Zenkaku SPC delims in headings;;
104;mb-space.at:19;Zenkaku SPC delims in record def;;
105;mb-space.at:43;Zenkaku SPC delims in COPY stmt;;
"

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

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

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

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

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

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

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

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

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

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

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

    --trace | -x )
	at_traceon='set -x'; at_traceoff='set +x'
	;;

    [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9])
	at_func_validate_ranges at_option
	at_groups="$at_groups$at_option "
	;;

    # Ranges
    [0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-)
	at_range_start=`echo $at_option |tr -d X-`
	at_func_validate_ranges at_range_start
	at_range=`$as_echo " $at_groups_all " | \
	  sed -e 's/^.* \('$at_range_start' \)/\1/'`
	at_groups="$at_groups$at_range "
	;;

    -[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9])
	at_range_end=`echo $at_option |tr -d X-`
	at_func_validate_ranges at_range_end
	at_range=`$as_echo " $at_groups_all " | \
	  sed -e 's/\( '$at_range_end'\) .*$/\1/'`
	at_groups="$at_groups$at_range "
	;;

    [0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9] | \
    [0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9] | \
    [0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] )
	at_range_start=`expr $at_option : '\(.*\)-'`
	at_range_end=`expr $at_option : '.*-\(.*\)'`
	if test $at_range_start -gt $at_range_end; then
	  at_tmp=$at_range_end
	  at_range_end=$at_range_start
	  at_range_start=$at_tmp
	fi
	at_func_validate_ranges at_range_start at_range_end
	at_range=`$as_echo " $at_groups_all " | \
	  sed -e 's/^.*\( '$at_range_start' \)/\1/' \
	      -e 's/\( '$at_range_end'\) .*$/\1/'`
	at_groups="$at_groups$at_range "
	;;

    # Directory selection.
    --directory | -C )
	at_prev=--directory
	;;
    --directory=* )
	at_change_dir=:
	at_dir=$at_optarg
	;;

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

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

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

# Verify our last option didn't require an argument
if test -n "$at_prev"; then
  { { $as_echo "$as_me:$LINENO: error: \`$at_prev' requires an argument." >&5
$as_echo "$as_me: error: \`$at_prev' requires an argument." >&2;}
   { (exit 1); exit 1; }; }
fi


# Selected test groups.
if test -z "$at_groups"; then
  at_groups=$at_groups_all
else
  # Sort the tests, removing duplicates.
  at_groups=`$as_echo "$at_groups" | tr ' ' "$as_nl" | sort -nu`
fi

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

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

You should not change environment variables unless explicitly passed
as command line arguments.  Set \`AUTOTEST_PATH' to select the executables
to exercise.  Each relative directory is expanded as build and source
directories relatively to the top level of this distribution.  E.g.,

  $ $0 AUTOTEST_PATH=bin

possibly amounts into

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

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

Execution tuning:
  -C, --directory=DIR
                 change to directory DIR before starting
  -k, --keywords=KEYWORDS
                 select the tests matching all the comma-separated KEYWORDS
                 multiple \`-k' accumulate; prefixed \`!' negates a KEYWORD
  -e, --errexit  abort as soon as a test fails; implies --debug
  -v, --verbose  force more detailed output
                 default for debugging scripts
  -d, --debug    inhibit clean up and top-level logging
                 default for debugging scripts
  -x, --trace    enable tests shell tracing
_ATEOF
cat <<_ATEOF || at_write_fail=1

Report bugs to <open-cobol-list@lists.sourceforge.net>.
_ATEOF
  exit $at_write_fail
fi

# List of tests.
if $at_list_p; then
  cat <<_ATEOF || at_write_fail=1
OpenCOBOL 1.1 test suite: I18n Shift_JIS Tests test groups:

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

_ATEOF
  # Passing at_groups is tricky.  We cannot use it to form a literal string
  # or regexp because of the limitation of AIX awk.  And Solaris' awk
  # doesn't grok more than 99 fields in a record, so we have to use `split'.
  # at_groups needs to be space-separated for this script to work.
  case $at_groups in
    *"$as_nl"* )
      at_groups=`$as_echo "$at_groups" | tr "$as_nl" ' '` ;;
  esac
  $as_echo "$at_groups$as_nl$at_help_all" |
    awk 'BEGIN { FS = ";" }
	 NR == 1 {
	   for (n = split($ 0, a, " "); n; n--) selected[a[n]] = 1
	   next
	 }
	 {
	   if (selected[$ 1]) {
	     printf " %3d: %-18s %s\n", $ 1, $ 2, $ 3
	     if ($ 4) printf "      %s\n", $ 4
	   }
	 }' || at_write_fail=1
  exit $at_write_fail
fi
if $at_version_p; then
  $as_echo "$as_me (OpenCOBOL 1.1)" &&
  cat <<\_ACEOF || at_write_fail=1

Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
Free Software Foundation, Inc.
This test suite is free software; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
_ACEOF
  exit $at_write_fail
fi

# Should we print banners?  at_groups is space-separated for entire test,
# newline-separated if only a subset of the testsuite is run.
case $at_groups in
  *' '*' '* | *"$as_nl"*"$as_nl"* )
      at_print_banners=: ;;
  * ) at_print_banners=false ;;
esac
# Text for banner N, set to empty once printed.

# Take any -C into account.
if $at_change_dir ; then
  if test x- = "x$at_dir" ; then
    at_dir=./-
  fi
  test x != "x$at_dir" && cd "$at_dir" \
    || { { $as_echo "$as_me:$LINENO: error: unable to change directory" >&5
$as_echo "$as_me: error: unable to change directory" >&2;}
   { (exit 1); exit 1; }; }
  at_dir=`pwd`
fi

# Load the config files for any default variable assignments.
for at_file in atconfig atlocal
do
  test -r $at_file || continue
  . ./$at_file || { { $as_echo "$as_me:$LINENO: error: invalid content: $at_file" >&5
$as_echo "$as_me: error: invalid content: $at_file" >&2;}
   { (exit 1); exit 1; }; }
done

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

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

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

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

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

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

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

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


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

PATH=$at_new_path
export PATH

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

# Banners and logs.
cat <<\_ASBOX
## ----------------------------------------------- ##
## OpenCOBOL 1.1 test suite: I18n Shift_JIS Tests. ##
## ----------------------------------------------- ##
_ASBOX
{
  cat <<\_ASBOX
## ----------------------------------------------- ##
## OpenCOBOL 1.1 test suite: I18n Shift_JIS Tests. ##
## ----------------------------------------------- ##
_ASBOX
  echo

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

  # Try to find a few ChangeLogs in case it might help determining the
  # exact version.  Use the relative dir: if the top dir is a symlink,
  # find will not follow it (and options to follow the links are not
  # portable), which would result in no output here.  Prune directories
  # matching the package tarname, since they tend to be leftovers from
  # `make dist' or `make distcheck' and contain redundant or stale logs.
  if test -n "$at_top_srcdir"; then
    cat <<\_ASBOX
## ----------- ##
## ChangeLogs. ##
## ----------- ##
_ASBOX
    echo
    for at_file in `find "$at_top_srcdir" -name "opensource-cobol-1.5.0J-*" -prune -o -name ChangeLog -print`
    do
      $as_echo "$as_me: $at_file:"
      sed 's/^/| /;10q' $at_file
      echo
    done

  fi

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

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

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

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

_ASUNAME

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

}
  echo

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


## --------------- ##
## Shell functions ##
## --------------- ##

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

# at_func_check_newline COMMAND
# -----------------------------
# Test if COMMAND includes a newline and, if so, print a message and return
# exit code 1
at_func_check_newline ()
{
  case "$1" in
 *'
'*) echo 'Not enabling shell tracing (command contains an embedded newline)'
    return 1 ;;
 *) return 0 ;;
  esac
}

# at_func_filter_trace EXIT-CODE
# ------------------------------
# Split the contents of file "$at_stder1" into the "set -x" trace (on stderr)
# and the other lines (on file "$at_stderr").  Return the exit code EXIT-CODE.
at_func_filter_trace ()
{
  grep '^ *+' "$at_stder1" >&2
  grep -v '^ *+' "$at_stder1" >"$at_stderr"
  return $1
}

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

# at_func_check_skip EXIT-CODE
# ----------------------------
# Check whether EXIT-CODE is the special exit code 77, and if so exit the shell
# with that same exit code.
at_func_check_skip ()
{
  case $1 in
    77) echo 77 > "$at_status_file"; exit 77;;
  esac
}

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

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

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

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

# at_func_arith
# -------------
# Arithmetic evaluation, avoids expr if the shell is sane.  The
# interpretation of leading zeroes is unspecified.
#
# subshell and eval are needed to keep Solaris sh from bailing out:
if ( eval 'test $(( 1 + 1 )) = 2' ) 2>/dev/null; then
  # With "$@", bash does not split positional parameters:
  eval 'at_func_arith ()
  {
    at_func_arith_result=$(( $* ))
  }'
else
  at_func_arith ()
  {
    at_func_arith_result=`expr "$@"`
  }
fi

## ---------------------- ##
## End of shell functions ##
## ---------------------- ##
{
  cat <<\_ASBOX
## ---------------- ##
## Tested programs. ##
## ---------------- ##
_ASBOX
  echo
} >&5

# Report what programs are being tested.
for at_program in : $at_tested
do
  test "$at_program" = : && continue
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -f "$as_dir/$at_program" && break
done
IFS=$as_save_IFS

  if test -f "$as_dir/$at_program"; then
    {
      $as_echo "$at_srcdir/i18n_sjis.at:21: $as_dir/$at_program --version"
      "$as_dir/$at_program" --version </dev/null
      echo
    } >&5 2>&1
  else
    { { $as_echo "$as_me:$LINENO: error: cannot find $at_program" >&5
$as_echo "$as_me: error: cannot find $at_program" >&2;}
   { (exit 1); exit 1; }; }
  fi
done

{
  cat <<\_ASBOX
## ------------------ ##
## Running the tests. ##
## ------------------ ##
_ASBOX
} >&5

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

# Create the master directory if it doesn't already exist.
test -d "$at_suite_dir" ||
  mkdir "$at_suite_dir" ||
  { { $as_echo "$as_me:$LINENO: error: cannot create '$at_suite_dir'" >&5
$as_echo "$as_me: error: cannot create '$at_suite_dir'" >&2;}
   { (exit 1); exit 1; }; }

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

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

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

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

# Set up helper dirs.
rm -rf "$at_helper_dir" &&
mkdir "$at_helper_dir" &&
cd "$at_helper_dir" &&
{ test -z "$at_groups" || mkdir $at_groups; } ||
{ { $as_echo "$as_me:$LINENO: error: testsuite directory setup failed" >&5
$as_echo "$as_me: error: testsuite directory setup failed" >&2;}
   { (exit 1); exit 1; }; }

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

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

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

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

  at_group_normalized=$at_group

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


  # Create a fresh directory for the next test group, and enter.
  at_group_dir=$at_suite_dir/$at_group_normalized
  at_group_log=$at_group_dir/$as_me.log
  if test -d "$at_group_dir"; then
    find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
    rm -fr "$at_group_dir" ||
    { $as_echo "$as_me:$LINENO: WARNING: test directory for $at_group_normalized could not be cleaned." >&5
$as_echo "$as_me: WARNING: test directory for $at_group_normalized could not be cleaned." >&2;}
  fi
  # Be tolerant if the above `rm' was not able to remove the directory.
  { as_dir="$at_group_dir"
  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
$as_echo "$as_me: error: cannot create directory $as_dir" >&2;}
   { (exit 1); exit 1; }; }; }

  echo 0 > "$at_status_file"

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

# at_func_group_postprocess
# -------------------------
at_func_group_postprocess ()
{
  # Be sure to come back to the suite directory, in particular
  # since below we might `rm' the group directory we are in currently.
  cd "$at_suite_dir"

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

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

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


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

rm -f "$at_stop_file"
at_first=:

for at_group in $at_groups; do
  at_func_group_prepare
  if cd "$at_group_dir" &&
     at_func_test $at_group &&
     . "$at_test_source"; then :; else
    { $as_echo "$as_me:$LINENO: WARNING: unable to parse test group: $at_group" >&5
$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;}
    at_failed=:
  fi
  at_func_group_postprocess
  test -f "$at_stop_file" && break
  at_first=false
done

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

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

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

at_func_arith $at_group_count - $at_skip_count
at_run_count=$at_func_arith_result
at_func_arith $at_xpass_count + $at_fail_count
at_unexpected_count=$at_func_arith_result
at_func_arith $at_xfail_count + $at_fail_count
at_total_fail_count=$at_func_arith_result

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

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

echo
cat <<\_ASBOX
## ------------- ##
## Test results. ##
## ------------- ##
_ASBOX
echo
{
  echo
  cat <<\_ASBOX
## ------------- ##
## Test results. ##
## ------------- ##
_ASBOX
  echo
} >&5

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

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

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

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

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

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

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

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

if test $at_unexpected_count = 0; then
  echo "$at_result"
  echo "$at_result" >&5
else
  echo "ERROR: $at_result" >&2
  echo "ERROR: $at_result" >&5
  {
    echo
    cat <<\_ASBOX
## ------------------------ ##
## Summary of the failures. ##
## ------------------------ ##
_ASBOX

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

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

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

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

  echo
  $as_echo "Please send \`${at_testdir+${at_testdir}/}$as_me.log' and all information you think might help:

   To: <open-cobol-list@lists.sourceforge.net>
   Subject: [OpenCOBOL 1.1] $as_me: $at_fail_list${at_fail_list:+ failed${at_xpass_list:+, }}$at_xpass_list${at_xpass_list:+ passed unexpectedly}
"
  if test $at_debug_p = false; then
    echo
    echo 'You may investigate any problem if you feel able to do so, in which'
    echo 'case the test suite provides a good starting point.  Its output may'
    $as_echo "be found below \`${at_testdir+${at_testdir}/}$as_me.dir'."
    echo
  fi
    exit 1
fi

exit 0

## ------------- ##
## Actual tests. ##
## ------------- ##
#AT_START_1
# 1. user-defined-word.at:1: Program name
at_setup_line='user-defined-word.at:1'
at_desc="Program name"
$at_quiet $as_echo_n "  1: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "1. user-defined-word.at:1: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      {̃vO.
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:10: \${COMPILE} -x prog.cob"
echo user-defined-word.at:10 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:10"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_1
#AT_START_2
# 2. user-defined-word.at:14: Field name
at_setup_line='user-defined-word.at:14'
at_desc="Field name"
$at_quiet $as_echo_n "  2: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "2. user-defined-word.at:14: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 n| PIC X(7) USAGE DISPLAY.
       PROCEDURE        DIVISION.
           MOVE "Unicode" TO n|.
           DISPLAY n| WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:28: \${COMPILE} -x prog.cob"
echo user-defined-word.at:28 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:28"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:29: ./prog"
echo user-defined-word.at:29 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Unicode" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:29"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_2
#AT_START_3
# 3. user-defined-word.at:33: Long field name
at_setup_line='user-defined-word.at:33'
at_desc="Long field name"
$at_quiet $as_echo_n "  3: $at_desc                                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "3. user-defined-word.at:33: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01   ڂ`abcdefgOPQRS5
            PIC X(7).
       PROCEDURE        DIVISION.
           MOVE "Unicode"
             TO
           ڂ`abcdefgOPQRS5.
           DISPLAY
            ڂ`abcdefgOPQRS5
	     WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:52: \${COMPILE} -x prog.cob"
echo user-defined-word.at:52 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:52"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:53: ./prog"
echo user-defined-word.at:53 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Unicode" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:53"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_3
#AT_START_4
# 4. user-defined-word.at:58: Field lookup
at_setup_line='user-defined-word.at:58'
at_desc="Field lookup"
$at_quiet $as_echo_n "  4: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "4. user-defined-word.at:58: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 ڂQ PIC X(1) VALUE "A".
       01 ڂq PIC X(1) VALUE "B".
       PROCEDURE        DIVISION.
           DISPLAY ڂQ ڂq WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:72: \${COMPILE} -x prog.cob"
echo user-defined-word.at:72 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:72"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:73: ./prog"
echo user-defined-word.at:73 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "AB" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:73"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_4
#AT_START_5
# 5. user-defined-word.at:77: Section name
at_setup_line='user-defined-word.at:77'
at_desc="Section name"
$at_quiet $as_echo_n "  5: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "5. user-defined-word.at:77: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
       PERFORM    r|.
       PERFORM    r|I.
       r|       SECTION.
           DISPLAY "Hello, " WITH NO ADVANCING.
       r|I         SECTION.
           DISPLAY "and good bye." WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:94: \${COMPILE} -x prog.cob"
echo user-defined-word.at:94 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:94"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:95: ./prog"
echo user-defined-word.at:95 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Hello, and good bye." | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:95"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_5
#AT_START_6
# 6. user-defined-word.at:99: Long section name
at_setup_line='user-defined-word.at:99'
at_desc="Long section name"
$at_quiet $as_echo_n "  6: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "6. user-defined-word.at:99: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
       PERFORM sPQRSTUVWXO1234567890.
       PERFORM    r|I.
       sPQRSTUVWXO1234567890 SECTION.
           DISPLAY "Hello, " WITH NO ADVANCING.
       r|I         SECTION.
           DISPLAY "and good bye." WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:116: \${COMPILE} -x prog.cob"
echo user-defined-word.at:116 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:116"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:117: ./prog"
echo user-defined-word.at:117 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Hello, and good bye." | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:117"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_6
#AT_START_7
# 7. user-defined-word.at:121: Too long section name
at_setup_line='user-defined-word.at:121'
at_desc="Too long section name"
$at_quiet $as_echo_n "  7: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "7. user-defined-word.at:121: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
       PERFORM sPQRSTUVWXO123456789012345678901.
       PERFORM    r|I.
       sPQRSTUVWXO123456789012345678901 SECTION.
           DISPLAY "Hello, " WITH NO ADVANCING.
       r|I         SECTION.
           DISPLAY "and good bye." WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:138: \${COMPILE} -x prog.cob"
echo user-defined-word.at:138 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:7: Error: User defined name must be less than 32 characters
prog.cob:9: Error: User defined name must be less than 32 characters
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:138"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_7
#AT_START_8
# 8. user-defined-word.at:145: Nihongo Filename
at_setup_line='user-defined-word.at:145'
at_desc="Nihongo Filename"
$at_quiet $as_echo_n "  8: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "8. user-defined-word.at:145: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT eXgt@C ASSIGN TO "./eXg_t@C"
                        ORGANIZATION IS  INDEXED
                        ACCESS MODE  IS  SEQUENTIAL
                        RECORD KEY   IS  TEST-KEY.
       DATA             DIVISION.
       FILE             SECTION.
       FD eXgt@C.
       01 TEST-KEY      PIC X(10).
       PROCEDURE        DIVISION.
           OPEN  OUTPUT eXgt@C.
           MOVE "TEST000000" TO TEST-KEY.
           WRITE TEST-KEY.
           CLOSE eXgt@C.
           OPEN  INPUT  eXgt@C.
           READ  eXgt@C
               NOT AT END
                   DISPLAY "OK" NO ADVANCING
           END-READ.
           CLOSE eXgt@C.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:175: \${COMPILE} -x prog.cob"
echo user-defined-word.at:175 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:175"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:176: ./prog"
echo user-defined-word.at:176 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:176"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_8
#AT_START_9
# 9. user-defined-word.at:180: Nihongo field name in numeric test msg.
at_setup_line='user-defined-word.at:180'
at_desc="Nihongo field name in numeric test msg."
$at_quiet $as_echo_n "  9: $at_desc        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "9. user-defined-word.at:180: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       numcheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  TEST-REC.
         03  U  PIC  9(4) VALUE  1000.
       01  X    PIC  X(4) VALUE 'ABCD'.
       PROCEDURE         DIVISION.
           MOVE X TO TEST-REC.
           ADD 1 TO U.
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:196: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:196 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:196"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:197: ./prog"
echo user-defined-word.at:197 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:11: libcob: 'U' not numeric: 'ABCD'
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:197"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_9
#AT_START_10
# 10. user-defined-word.at:203: Nihongo field name in BASED test msg.
at_setup_line='user-defined-word.at:203'
at_desc="Nihongo field name in BASED test msg."
$at_quiet $as_echo_n " 10: $at_desc          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "10. user-defined-word.at:203: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       basedcheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  X    PIC  X(4) VALUE 'ABCD'.
       01  Y    PIC  X(4) BASED.
       PROCEDURE         DIVISION.
           MOVE X TO Y.
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:217: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:217 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:217"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:218: ./prog"
echo user-defined-word.at:218 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:9: libcob: BASED/LINKAGE item 'Y' has NULL address
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:218"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_10
#AT_START_11
# 11. user-defined-word.at:224: Nihongo field name in ODO test msg.
at_setup_line='user-defined-word.at:224'
at_desc="Nihongo field name in ODO test msg."
$at_quiet $as_echo_n " 11: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "11. user-defined-word.at:224: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       odocheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  I         PIC 9 VALUE 4.
       01  X.
         03  Y       PIC 9 OCCURS 1 TO 3 DEPENDING ON I.
       PROCEDURE         DIVISION.
           MOVE 1 TO Y(3).
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:239: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:239 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:239"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:240: ./prog"
echo user-defined-word.at:240 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: OCCURS DEPENDING ON 'I' out of bounds: 4
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:240"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_11
#AT_START_12
# 12. user-defined-word.at:246: Nihongo field name in Subscript test msg.
at_setup_line='user-defined-word.at:246'
at_desc="Nihongo field name in Subscript test msg."
$at_quiet $as_echo_n " 12: $at_desc      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "12. user-defined-word.at:246: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       odocheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  I         PIC 9 VALUE 2.
       01  X.
         03  Y       PIC 9 OCCURS 1 TO 3 DEPENDING ON I.
       PROCEDURE         DIVISION.
           MOVE 1 TO Y(3).
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:261: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:261 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:261"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:262: ./prog"
echo user-defined-word.at:262 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'Y' out of bounds: 3
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:262"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_12
#AT_START_13
# 13. user-defined-word.at:268: Nihongo field name in length of ref_mod test msg.
at_setup_line='user-defined-word.at:268'
at_desc="Nihongo field name in length of ref_mod test msg."
$at_quiet $as_echo_n " 13: $at_desc"
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "13. user-defined-word.at:268: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       refcheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  I             PIC 9    VALUE 2.
       01  J             PIC 9    VALUE 6.
       01  X         PIC X(5) VALUE "ABCDE".
       PROCEDURE         DIVISION.
           DISPLAY X(I:J).
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:283: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:283 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:283"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:284: ./prog"
echo user-defined-word.at:284 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Length of 'X' out of bounds: 6
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:284"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_13
#AT_START_14
# 14. user-defined-word.at:290: Nihongo field name in offset of ref_mod test msg.
at_setup_line='user-defined-word.at:290'
at_desc="Nihongo field name in offset of ref_mod test msg."
$at_quiet $as_echo_n " 14: $at_desc"
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "14. user-defined-word.at:290: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       refcheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  I             PIC 9    VALUE 6.
       01  J             PIC 9    VALUE 2.
       01  X         PIC X(5) VALUE "ABCDE".
       PROCEDURE         DIVISION.
           DISPLAY X(I:J).
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:305: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:305 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:305"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:306: ./prog"
echo user-defined-word.at:306 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Offset of 'X' out of bounds: 6
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:306"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_14
#AT_START_15
# 15. user-defined-word.at:312: Nihongo field name in length of N_refmod test msg.
at_setup_line='user-defined-word.at:312'
at_desc="Nihongo field name in length of N_refmod test msg."
$at_quiet $as_echo_n " 15: $at_desc"
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "15. user-defined-word.at:312: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       refcheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  I             PIC 9    VALUE 2.
       01  J             PIC 99   VALUE 18.
       01  X         PIC N(5) VALUE "`abcd".
       PROCEDURE         DIVISION.
           DISPLAY X(I:J).
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:327: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:327 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:327"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:328: ./prog"
echo user-defined-word.at:328 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Length of 'X' out of bounds: 18
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:328"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_15
#AT_START_16
# 16. user-defined-word.at:334: Nihongo field name in offset of N_refmod test msg.
at_setup_line='user-defined-word.at:334'
at_desc="Nihongo field name in offset of N_refmod test msg."
$at_quiet $as_echo_n " 16: $at_desc"
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "16. user-defined-word.at:334: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       refcheck.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  I             PIC 99   VALUE 18.
       01  J             PIC 9    VALUE 2.
       01  X         PIC N(5) VALUE "`abcd".
       PROCEDURE         DIVISION.
           DISPLAY X(I:J).
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:349: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:349 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:349"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:350: ./prog"
echo user-defined-word.at:350 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Offset of 'X' out of bounds: 18
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:350"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_16
#AT_START_17
# 17. user-defined-word.at:356: Nihongo field name in extaddr test msg.
at_setup_line='user-defined-word.at:356'
at_desc="Nihongo field name in extaddr test msg."
$at_quiet $as_echo_n " 17: $at_desc        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "17. user-defined-word.at:356: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       check1.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  X         PIC X(5) EXTERNAL.
       PROCEDURE         DIVISION.
           CALL 'check2'.

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       check2.
       DATA              DIVISION.
       WORKING-STORAGE   SECTION.
       01  X         PIC X(6) EXTERNAL.
       PROCEDURE         DIVISION.
           END PROGRAM check2.
           END PROGRAM check1.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:377: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:377 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/user-defined-word.at:377"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:378: ./prog"
echo user-defined-word.at:378 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: libcob: EXTERNAL item 'X' has size > 6
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:378"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_17
#AT_START_18
# 18. user-defined-word.at:384: Nihongo field name in undefined error msg.
at_setup_line='user-defined-word.at:384'
at_desc="Nihongo field name in undefined error msg."
$at_quiet $as_echo_n " 18: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "18. user-defined-word.at:384: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 GWc.
          03 A PIC X.
       PROCEDURE        DIVISION.
001009     DISPLAY NO-FLD.
001010     DISPLAY NO-FLD IN G-GRP.
001011     DISPLAY NO-FLD IN NO-GRP.
001012     DISPLAY NO.
001013     DISPLAY NO IN GWc.
001014     DISPLAY NO IN NOWc.
001015     DISPLAY NO-FLD IN GWc.
001016     DISPLAY NO-FLD IN NOWc.
001017     DISPLAY NO IN G-GRP.
001018     DISPLAY NO IN NO-GRP.
001019     DISPLAY NO IN GWc IN NOWc.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:407: \${COMPILE} -debug -x prog.cob"
echo user-defined-word.at:407 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:9: Error: 'NO-FLD' undefined
prog.cob:10: Error: 'NO-FLD' in 'G-GRP' undefined
prog.cob:11: Error: 'NO-FLD' in 'NO-GRP' undefined
prog.cob:12: Error: 'NO' undefined
prog.cob:13: Error: 'NO' in 'GWc' undefined
prog.cob:14: Error: 'NO' in 'NOWc' undefined
prog.cob:15: Error: 'NO-FLD' in 'GWc' undefined
prog.cob:16: Error: 'NO-FLD' in 'NOWc' undefined
prog.cob:17: Error: 'NO' in 'G-GRP' undefined
prog.cob:18: Error: 'NO' in 'NO-GRP' undefined
prog.cob:19: Error: 'NO' in 'GWc' in 'NOWc' undefined
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:407"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_18
#AT_START_19
# 19. user-defined-word.at:423: Nihongo field name in ambiguous error msg.
at_setup_line='user-defined-word.at:423'
at_desc="Nihongo field name in ambiguous error msg."
$at_quiet $as_echo_n " 19: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "19. user-defined-word.at:423: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 A PIC X.
       01 G1Wc.
          03 A PIC X.
          03 B PIC X.
          03 G2Wc.
             05 A PIC X.
             05 B PIC X.
       PROCEDURE        DIVISION.
001014     DISPLAY A.
001015     DISPLAY B IN G1Wc.
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:443: \${COMPILE_ONLY} prog.cob"
echo user-defined-word.at:443 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Warning: Redefinition of 'A'
prog.cob:6: Warning: 'A' previously defined here
prog.cob:11: Warning: Redefinition of 'A'
prog.cob:6: Warning: 'A' previously defined here
prog.cob:14: Error: 'A' ambiguous; need qualification
prog.cob:6: Error: 'A' defined here
prog.cob:8: Error: 'A' in 'G1Wc' defined here
prog.cob:11: Error: 'A' in 'G2Wc' in 'G1Wc' defined here
prog.cob:15: Error: 'B' in 'G1Wc' ambiguous; need qualification
prog.cob:9: Error: 'B' in 'G1Wc' defined here
prog.cob:12: Error: 'B' in 'G2Wc' in 'G1Wc' defined here
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:443"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_19
#AT_START_20
# 20. user-defined-word.at:459: Nihongo label name in ambiguous error msg.
at_setup_line='user-defined-word.at:459'
at_desc="Nihongo label name in ambiguous error msg."
$at_quiet $as_echo_n " 20: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "20. user-defined-word.at:459: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       PROCEDURE        DIVISION.
001006   L0o.
001007     GO TO L1o.
001008     GO TO L2o IN S1.
001009   L1o. GOBACK.
001010   L1o. GOBACK.
001011 S1             SECTION.
001012   L2o. GOBACK.
001013   L2o. GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/user-defined-word.at:476: \${COMPILE_ONLY} prog.cob"
echo user-defined-word.at:476 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:7: Error: 'L1o' ambiguous; need qualification
prog.cob:9: Error: 'L1o' in 'MAIN SECTION' defined here
prog.cob:10: Error: 'L1o' in 'MAIN SECTION' defined here
prog.cob:8: Error: 'L2o' in 'S1' ambiguous; need qualification
prog.cob:12: Error: 'L2o' in 'S1' defined here
prog.cob:13: Error: 'L2o' in 'S1' defined here
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/user-defined-word.at:476"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_20
#AT_START_21
# 21. pic-x.at:1: Value clause
at_setup_line='pic-x.at:1'
at_desc="Value clause"
$at_quiet $as_echo_n " 21: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "21. pic-x.at:1: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(14) VALUE "{̕".
       PROCEDURE        DIVISION.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:14: \${COMPILE} -x prog.cob"
echo pic-x.at:14 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:14"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:15: ./prog"
echo pic-x.at:15 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{̕" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:15"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_21
#AT_START_22
# 22. pic-x.at:19: Move
at_setup_line='pic-x.at:19'
at_desc="Move"
$at_quiet $as_echo_n " 22: $at_desc                                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "22. pic-x.at:19: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(14).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:33: \${COMPILE} -x prog.cob"
echo pic-x.at:33 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:33"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:34: ./prog"
echo pic-x.at:34 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{̕" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:34"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_22
#AT_START_23
# 23. pic-x.at:38: Move with trunc
at_setup_line='pic-x.at:38'
at_desc="Move with trunc"
$at_quiet $as_echo_n " 23: $at_desc                                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "23. pic-x.at:38: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(6).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:52: \${COMPILE} -x prog.cob"
echo pic-x.at:52 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Warning: Value size exceeds data size
prog.cob:6: Warning: 'F0' defined here as PIC X(6)
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:52"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:56: ./prog"
echo pic-x.at:56 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:56"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_23
#AT_START_24
# 24. pic-x.at:60: Move ALL with trunc and trimming
at_setup_line='pic-x.at:60'
at_desc="Move ALL with trunc and trimming"
$at_quiet $as_echo_n " 24: $at_desc               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "24. pic-x.at:60: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(7).
       PROCEDURE        DIVISION.
           MOVE ALL "" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:74: \${COMPILE} -x prog.cob"
echo pic-x.at:74 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:74"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:75: ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *\$//'"
echo pic-x.at:75 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//'"; then
  ( $at_traceon; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 8a ec 8a ec 8a ec 20
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:75"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_24
#AT_START_25
# 25. pic-x.at:80: Move with trunc and trimming 1
at_setup_line='pic-x.at:80'
at_desc="Move with trunc and trimming 1"
$at_quiet $as_echo_n " 25: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "25. pic-x.at:80: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(7).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:94: \${COMPILE} -x prog.cob"
echo pic-x.at:94 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Warning: Value size exceeds data size
prog.cob:6: Warning: 'F0' defined here as PIC X(7)
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:94"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:98: ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *\$//'"
echo pic-x.at:98 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//'"; then
  ( $at_traceon; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 93 fa 96 7b 8c ea 82
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:98"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_25
#AT_START_26
# 26. pic-x.at:103: Move from field with trunc and trimming 1
at_setup_line='pic-x.at:103'
at_desc="Move from field with trunc and trimming 1"
$at_quiet $as_echo_n " 26: $at_desc      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "26. pic-x.at:103: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 FS PIC X(14) VALUE "{̕".
       01 F0 PIC X(7).
       PROCEDURE        DIVISION.
           MOVE FS TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:118: \${COMPILE} -x prog.cob"
echo pic-x.at:118 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:118"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:119: ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *\$//'"
echo pic-x.at:119 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//'"; then
  ( $at_traceon; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 93 fa 96 7b 8c ea 82
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:119"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_26
#AT_START_27
# 27. pic-x.at:124: Move with padding
at_setup_line='pic-x.at:124'
at_desc="Move with padding"
$at_quiet $as_echo_n " 27: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "27. pic-x.at:124: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(16).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:138: \${COMPILE} -x prog.cob"
echo pic-x.at:138 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:138"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:139: ./prog"
echo pic-x.at:139 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{̕  " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:139"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_27
#AT_START_28
# 28. pic-x.at:143: Move with justify
at_setup_line='pic-x.at:143'
at_desc="Move with justify"
$at_quiet $as_echo_n " 28: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "28. pic-x.at:143: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(15) JUSTIFIED RIGHT.
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:157: \${COMPILE} -x prog.cob"
echo pic-x.at:157 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:157"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:158: ./prog"
echo pic-x.at:158 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " {̕" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:158"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_28
#AT_START_29
# 29. pic-x.at:162: Move to alnum EDITED
at_setup_line='pic-x.at:162'
at_desc="Move to alnum EDITED"
$at_quiet $as_echo_n " 29: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "29. pic-x.at:162: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC XXXX/XXXXBXXXX0.
       PROCEDURE        DIVISION.
           MOVE "{" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:176: \${COMPILE} -x prog.cob"
echo pic-x.at:176 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:176"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:177: ./prog"
echo pic-x.at:177 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{/ 0" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:177"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_29
#AT_START_30
# 30. pic-x.at:181: Move to alnum EDITED (pic too short)
at_setup_line='pic-x.at:181'
at_desc="Move to alnum EDITED (pic too short)"
$at_quiet $as_echo_n " 30: $at_desc           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "30. pic-x.at:181: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC XX/XXBXX0.
       PROCEDURE        DIVISION.
           MOVE "{" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:195: \${COMPILE} -x prog.cob"
echo pic-x.at:195 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Warning: Value size exceeds data size
prog.cob:6: Warning: 'F0' defined here as PIC XX/XXBXX0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:195"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:199: ./prog"
echo pic-x.at:199 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "/{ 0" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:199"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_30
#AT_START_31
# 31. pic-x.at:203: Move to alnum EDITED (pic too long)
at_setup_line='pic-x.at:203'
at_desc="Move to alnum EDITED (pic too long)"
$at_quiet $as_echo_n " 31: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "31. pic-x.at:203: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC XX/XXBXX0.
       PROCEDURE        DIVISION.
           MOVE "{" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:217: \${COMPILE} -x prog.cob"
echo pic-x.at:217 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:217"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:218: ./prog"
echo pic-x.at:218 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "/{   0" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:218"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_31
#AT_START_32
# 32. pic-x.at:222: Move to alnum EDITED (No char break)
at_setup_line='pic-x.at:222'
at_desc="Move to alnum EDITED (No char break)"
$at_quiet $as_echo_n " 32: $at_desc           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "32. pic-x.at:222: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(2)BX(2).
       PROCEDURE        DIVISION.
           MOVE "{" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:236: \${COMPILE} -x prog.cob"
echo pic-x.at:236 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:236"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:237: ./prog"
echo pic-x.at:237 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " {" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:237"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_32
#AT_START_33
# 33. pic-x.at:241: Move to alnum EDITED (char break & junk chars)
at_setup_line='pic-x.at:241'
at_desc="Move to alnum EDITED (char break & junk chars)"
$at_quiet $as_echo_n " 33: $at_desc "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "33. pic-x.at:241: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(1)BX(3).
       PROCEDURE        DIVISION.
           MOVE "{" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:255: \${COMPILE} -x prog.cob"
echo pic-x.at:255 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:255"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:256: ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *\$//'"
echo pic-x.at:256 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//'"; then
  ( $at_traceon; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 93 20 fa 96 7b
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:256"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_33
#AT_START_34
# 34. pic-x.at:261: Move group to group in bad alignment
at_setup_line='pic-x.at:261'
at_desc="Move group to group in bad alignment"
$at_quiet $as_echo_n " 34: $at_desc           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "34. pic-x.at:261: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0.
       03     XX0    PIC X(4) VALUE "{".
       01 F1.
       03     XX1    PIC X(3).
       03     FILLER PIC X(1).

       PROCEDURE        DIVISION.
           MOVE   F0 TO F1.
           DISPLAY XX1 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:280: \${COMPILE} -x prog.cob"
echo pic-x.at:280 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:280"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:281: ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *\$//'"
echo pic-x.at:281 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//'"; then
  ( $at_traceon; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 93 fa 96
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:281"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_34
#AT_START_35
# 35. pic-x.at:286: Redifinition breaking char pos.
at_setup_line='pic-x.at:286'
at_desc="Redifinition breaking char pos."
$at_quiet $as_echo_n " 35: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "35. pic-x.at:286: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0.
       03     XX0    PIC X(4) VALUE "{".
       01 F1 REDEFINES F0.
       03     XX1    PIC X(3).
       03     FILLER PIC X(1).

       PROCEDURE        DIVISION.
           DISPLAY XX1 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:304: \${COMPILE} -x prog.cob"
echo pic-x.at:304 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:304"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:305: ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *\$//'"
echo pic-x.at:305 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//'"; then
  ( $at_traceon; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 93 fa 96
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:305"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_35
#AT_START_36
# 36. pic-x.at:311: Ref mod(n:)
at_setup_line='pic-x.at:311'
at_desc="Ref mod(n:)"
$at_quiet $as_echo_n " 36: $at_desc                                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "36. pic-x.at:311: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(14).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0(9:) WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:325: \${COMPILE} -x prog.cob"
echo pic-x.at:325 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:325"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:326: ./prog"
echo pic-x.at:326 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:326"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_36
#AT_START_37
# 37. pic-x.at:330: Ref mod(n:m)
at_setup_line='pic-x.at:330'
at_desc="Ref mod(n:m)"
$at_quiet $as_echo_n " 37: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "37. pic-x.at:330: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(14).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0(9:4) WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:344: \${COMPILE} -x prog.cob"
echo pic-x.at:344 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:344"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:345: ./prog"
echo pic-x.at:345 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:345"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_37
#AT_START_38
# 38. pic-x.at:349: STRING by size
at_setup_line='pic-x.at:349'
at_desc="STRING by size"
$at_quiet $as_echo_n " 38: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "38. pic-x.at:349: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(4)  VALUE "".
       01 F1 PIC X(6)  VALUE "O".
       01 F2 PIC X(10) VALUE "܂".
       01 FF PIC X(20).
       PROCEDURE        DIVISION.
           STRING F0 F1 F2 DELIMITED BY SIZE
             INTO FF.
           DISPLAY FF WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:367: \${COMPILE} -x prog.cob"
echo pic-x.at:367 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:367"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:368: ./prog"
echo pic-x.at:368 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "̖O͂܂" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:368"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_38
#AT_START_39
# 39. pic-x.at:372: STRING with delimiter
at_setup_line='pic-x.at:372'
at_desc="STRING with delimiter"
$at_quiet $as_echo_n " 39: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "39. pic-x.at:372: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(4)  VALUE "".
       01 F1 PIC X(8)  VALUE "O".
       01 F2 PIC X(12) VALUE "܂".
       01 FF PIC X(8).
       PROCEDURE        DIVISION.
           STRING F0 F1 F2 DELIMITED BY ""
             INTO FF.
           DISPLAY FF WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:390: \${COMPILE} -x prog.cob"
echo pic-x.at:390 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:12: Warning: F0 and '' and FF have not same national type!
prog.cob:12: Warning: F1 and '' and FF have not same national type!
prog.cob:12: Warning: F2 and '' and FF have not same national type!
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:390"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:395: ./prog"
echo pic-x.at:395 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "̖O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:395"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_39
#AT_START_40
# 40. pic-x.at:399: STRING with pointer
at_setup_line='pic-x.at:399'
at_desc="STRING with pointer"
$at_quiet $as_echo_n " 40: $at_desc                            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "40. pic-x.at:399: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(4)  VALUE "".
       01 F1 PIC X(6)  VALUE "O".
       01 F2 PIC X(10) VALUE "܂".
       01 FF PIC X(20) VALUE "܂񁛁~".
       01 FP PIC 99    VALUE 11.
       PROCEDURE        DIVISION.
           STRING F0 F1 F2 DELIMITED BY SIZE
             INTO FF WITH POINTER FP.
           DISPLAY FF WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:418: \${COMPILE} -x prog.cob"
echo pic-x.at:418 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:418"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:419: ./prog"
echo pic-x.at:419 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "܂񎄂̖O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:419"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_40
#AT_START_41
# 41. pic-x.at:423: INSPECT REPLACING
at_setup_line='pic-x.at:423'
at_desc="INSPECT REPLACING"
$at_quiet $as_echo_n " 41: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "41. pic-x.at:423: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(20)  VALUE "PQRSTPQRST".
       PROCEDURE        DIVISION.
           INSPECT F0 REPLACING ALL "T" BY "O".
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:437: \${COMPILE} -x prog.cob"
echo pic-x.at:437 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:437"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:438: ./prog"
echo pic-x.at:438 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "PQRSOPQRSO" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:438"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_41
#AT_START_42
# 42. pic-x.at:442: INSPECT REPLACING by ZERO
at_setup_line='pic-x.at:442'
at_desc="INSPECT REPLACING by ZERO"
$at_quiet $as_echo_n " 42: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "42. pic-x.at:442: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(20)  VALUE "PQRSTPQRST".
       PROCEDURE        DIVISION.
           INSPECT F0 REPLACING ALL "T" BY ZERO.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:456: \${COMPILE} -x prog.cob"
echo pic-x.at:456 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:456"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:457: ./prog"
echo pic-x.at:457 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "PQRSOPQRSO" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:457"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_42
#AT_START_43
# 43. pic-x.at:461: INSPECT TALLYING
at_setup_line='pic-x.at:461'
at_desc="INSPECT TALLYING"
$at_quiet $as_echo_n " 43: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "43. pic-x.at:461: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC X(30)  VALUE "PQRSTPQRST".
       01 CN PIC 99.
       PROCEDURE        DIVISION.
           INSPECT F0 TALLYING CN FOR ALL "ST".
           DISPLAY CN WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:476: \${COMPILE} -x prog.cob"
echo pic-x.at:476 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:476"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-x.at:477: ./prog"
echo pic-x.at:477 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "02" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-x.at:477"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_43
#AT_START_44
# 44. pic-n.at:1: PIC N Value clause
at_setup_line='pic-n.at:1'
at_desc="PIC N Value clause"
$at_quiet $as_echo_n " 44: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "44. pic-n.at:1: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7) VALUE "{̕".
       PROCEDURE        DIVISION.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:14: \${COMPILE} -x prog.cob"
echo pic-n.at:14 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:14"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:15: ./prog"
echo pic-n.at:15 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{̕" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:15"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_44
#AT_START_45
# 45. pic-n.at:19: PIC N Move
at_setup_line='pic-n.at:19'
at_desc="PIC N Move"
$at_quiet $as_echo_n " 45: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "45. pic-n.at:19: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:33: \${COMPILE} -x prog.cob"
echo pic-n.at:33 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:33"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:34: ./prog"
echo pic-n.at:34 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{̕" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:34"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_45
#AT_START_46
# 46. pic-n.at:38: PIC N Move with trunc
at_setup_line='pic-n.at:38'
at_desc="PIC N Move with trunc"
$at_quiet $as_echo_n " 46: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "46. pic-n.at:38: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(3).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:52: \${COMPILE} -x prog.cob"
echo pic-n.at:52 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Warning: Value size exceeds data size
prog.cob:6: Warning: 'F0' defined here as PIC N(3)
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:52"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:56: ./prog"
echo pic-n.at:56 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:56"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_46
#AT_START_47
# 47. pic-n.at:60: PIC N Move with padding by full-width SPC
at_setup_line='pic-n.at:60'
at_desc="PIC N Move with padding by full-width SPC"
$at_quiet $as_echo_n " 47: $at_desc      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "47. pic-n.at:60: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(9).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:74: \${COMPILE} -x prog.cob"
echo pic-n.at:74 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:74"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:75: ./prog"
echo pic-n.at:75 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{̕@@" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:75"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_47
#AT_START_48
# 48. pic-n.at:79: PIC N Move with justify
at_setup_line='pic-n.at:79'
at_desc="PIC N Move with justify"
$at_quiet $as_echo_n " 48: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "48. pic-n.at:79: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(9) JUSTIFIED RIGHT.
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:93: \${COMPILE} -x prog.cob"
echo pic-n.at:93 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:93"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:94: ./prog"
echo pic-n.at:94 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "@@{̕" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:94"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_48
#AT_START_49
# 49. pic-n.at:98: PIC N EDITED w/ VALUE
at_setup_line='pic-n.at:98'
at_desc="PIC N EDITED w/ VALUE"
$at_quiet $as_echo_n " 49: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "49. pic-n.at:98: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC NN/NNBNN0 VALUE '{^@O'.
       PROCEDURE        DIVISION.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:111: \${COMPILE} -x prog.cob"
echo pic-n.at:111 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:111"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:112: ./prog"
echo pic-n.at:112 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{^@O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:112"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_49
#AT_START_50
# 50. pic-n.at:116: INITIALIZE PIC N EDITED
at_setup_line='pic-n.at:116'
at_desc="INITIALIZE PIC N EDITED"
$at_quiet $as_echo_n " 50: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "50. pic-n.at:116: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC NN/NNBNN0 VALUE '{^@O'.
       PROCEDURE        DIVISION.
           MOVE "tďH~g" TO F0.
           INITIALIZE F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:131: \${COMPILE} -x prog.cob"
echo pic-n.at:131 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:131"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:132: ./prog"
echo pic-n.at:132 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "@@^@@@@@O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:132"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_50
#AT_START_51
# 51. pic-n.at:136: INITIALIZE PIC N EDITED TO VALUE
at_setup_line='pic-n.at:136'
at_desc="INITIALIZE PIC N EDITED TO VALUE"
$at_quiet $as_echo_n " 51: $at_desc               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "51. pic-n.at:136: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC NN/NNBNN0 VALUE '{^@O'.
       PROCEDURE        DIVISION.
           MOVE "tďH~g" TO F0.
           INITIALIZE F0 NATIONAL TO VALUE.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:151: \${COMPILE} -x prog.cob"
echo pic-n.at:151 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:151"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:152: ./prog"
echo pic-n.at:152 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{^@O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:152"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_51
#AT_START_52
# 52. pic-n.at:156: PIC N Move to NATIONAL EDITED
at_setup_line='pic-n.at:156'
at_desc="PIC N Move to NATIONAL EDITED"
$at_quiet $as_echo_n " 52: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "52. pic-n.at:156: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC NN/NNBNN0.
       PROCEDURE        DIVISION.
           MOVE "{" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:170: \${COMPILE} -x prog.cob"
echo pic-n.at:170 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:170"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:171: ./prog"
echo pic-n.at:171 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{^@O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:171"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_52
#AT_START_53
# 53. pic-n.at:175: PIC N Move with half-width alnum conv.
at_setup_line='pic-n.at:175'
at_desc="PIC N Move with half-width alnum conv."
$at_quiet $as_echo_n " 53: $at_desc         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "53. pic-n.at:175: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7).
       PROCEDURE        DIVISION.
           MOVE "ABC0123" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:189: \${COMPILE} -x prog.cob"
echo pic-n.at:189 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:189"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:190: ./prog"
echo pic-n.at:190 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "\`abOPQR" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:190"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_53
#AT_START_54
# 54. pic-n.at:194: PIC N Move with half-width kana conv.
at_setup_line='pic-n.at:194'
at_desc="PIC N Move with half-width kana conv."
$at_quiet $as_echo_n " 54: $at_desc          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "54. pic-n.at:194: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7).
       PROCEDURE        DIVISION.
           MOVE "޺˰" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:208: \${COMPILE} -x prog.cob"
echo pic-n.at:208 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:208"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:209: ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *\$//'"
echo pic-n.at:209 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//'"; then
  ( $at_traceon; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog | od -tx1 -An | sed -e 's/  */ /g' -e 's/ *$//' ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 83 52 83 81 83 5f 83 52 81 5b 83 71 81 5b
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:209"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_54
#AT_START_55
# 55. pic-n.at:214: PIC N Ref mod(n:)
at_setup_line='pic-n.at:214'
at_desc="PIC N Ref mod(n:)"
$at_quiet $as_echo_n " 55: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "55. pic-n.at:214: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0(5:) WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:228: \${COMPILE} -x prog.cob"
echo pic-n.at:228 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:228"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:229: ./prog"
echo pic-n.at:229 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:229"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_55
#AT_START_56
# 56. pic-n.at:233: PIC N Ref mod(n:m)
at_setup_line='pic-n.at:233'
at_desc="PIC N Ref mod(n:m)"
$at_quiet $as_echo_n " 56: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "56. pic-n.at:233: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7).
       PROCEDURE        DIVISION.
           MOVE "{̕" TO F0.
           DISPLAY F0(5:2) WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:247: \${COMPILE} -x prog.cob"
echo pic-n.at:247 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:247"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:248: ./prog"
echo pic-n.at:248 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:248"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_56
#AT_START_57
# 57. pic-n.at:252: PIC N STRING by size
at_setup_line='pic-n.at:252'
at_desc="PIC N STRING by size"
$at_quiet $as_echo_n " 57: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "57. pic-n.at:252: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(2)  VALUE "".
       01 F1 PIC N(3)  VALUE "O".
       01 F2 PIC N(5) VALUE "܂".
       01 FF PIC N(10).
       PROCEDURE        DIVISION.
           STRING F0 F1 F2 DELIMITED BY SIZE
             INTO FF.
           DISPLAY FF WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:270: \${COMPILE} -x prog.cob"
echo pic-n.at:270 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:270"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:271: ./prog"
echo pic-n.at:271 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "̖O͂܂" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:271"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_57
#AT_START_58
# 58. pic-n.at:275: PIC N STRING with delimiter (causes warn)
at_setup_line='pic-n.at:275'
at_desc="PIC N STRING with delimiter (causes warn)"
$at_quiet $as_echo_n " 58: $at_desc      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "58. pic-n.at:275: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(2)  VALUE "".
       01 F1 PIC N(4)  VALUE "O".
       01 F2 PIC N(6) VALUE "܂".
       01 FF PIC N(4).
       PROCEDURE        DIVISION.
           STRING F0 F1 F2 DELIMITED BY ""
             INTO FF.
           DISPLAY FF WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:293: \${COMPILE} -x prog.cob"
echo pic-n.at:293 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:293"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:294: ./prog"
echo pic-n.at:294 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "̖O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:294"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_58
#AT_START_59
# 59. pic-n.at:298: PIC N STRING with NATIONAL delimiter
at_setup_line='pic-n.at:298'
at_desc="PIC N STRING with NATIONAL delimiter"
$at_quiet $as_echo_n " 59: $at_desc           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "59. pic-n.at:298: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(2)  VALUE "".
       01 F1 PIC N(4)  VALUE "O".
       01 F2 PIC N(6) VALUE "܂".
       01 FF PIC N(4).
       PROCEDURE        DIVISION.
           STRING F0 F1 F2 DELIMITED BY N""
             INTO FF.
           DISPLAY FF WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:316: \${COMPILE} -x prog.cob"
echo pic-n.at:316 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:316"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:317: ./prog"
echo pic-n.at:317 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "̖O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:317"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_59
#AT_START_60
# 60. pic-n.at:321: PIC N STRING with pointer
at_setup_line='pic-n.at:321'
at_desc="PIC N STRING with pointer"
$at_quiet $as_echo_n " 60: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "60. pic-n.at:321: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(2)  VALUE "".
       01 F1 PIC N(3)  VALUE "O".
       01 F2 PIC N(5)  VALUE "܂".
       01 FF PIC N(10) VALUE "܂񁛁~".
       01 FP PIC 99    VALUE 6.
       PROCEDURE        DIVISION.
           STRING F0 F1 F2 DELIMITED BY SIZE
             INTO FF WITH POINTER FP.
           DISPLAY FF WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:340: \${COMPILE} -x prog.cob"
echo pic-n.at:340 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:340"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:341: ./prog"
echo pic-n.at:341 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "܂񎄂̖O" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:341"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_60
#AT_START_61
# 61. pic-n.at:345: PIC N INSPECT REPLACING
at_setup_line='pic-n.at:345'
at_desc="PIC N INSPECT REPLACING"
$at_quiet $as_echo_n " 61: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "61. pic-n.at:345: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(10)  VALUE "PQRSTPQRST".
       PROCEDURE        DIVISION.
           INSPECT F0 REPLACING ALL "T" BY "O".
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:359: \${COMPILE} -x prog.cob"
echo pic-n.at:359 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:359"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:360: ./prog"
echo pic-n.at:360 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "PQRSOPQRSO" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:360"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_61
#AT_START_62
# 62. pic-n.at:364: PIC N INSPECT REPLACING by ZERO
at_setup_line='pic-n.at:364'
at_desc="PIC N INSPECT REPLACING by ZERO"
$at_quiet $as_echo_n " 62: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "62. pic-n.at:364: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(10)  VALUE "PQRSTPQRST".
       PROCEDURE        DIVISION.
           INSPECT F0 REPLACING ALL "T" BY ZERO.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:378: \${COMPILE} -x prog.cob"
echo pic-n.at:378 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:378"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:379: ./prog"
echo pic-n.at:379 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "PQRSOPQRSO" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:379"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_62
#AT_START_63
# 63. pic-n.at:383: PIC N INSPECT REPLACING by NATIONAL ZERO
at_setup_line='pic-n.at:383'
at_desc="PIC N INSPECT REPLACING by NATIONAL ZERO"
$at_quiet $as_echo_n " 63: $at_desc       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "63. pic-n.at:383: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(10)  VALUE "PQRSTPQRST".
       PROCEDURE        DIVISION.
           INSPECT F0 REPLACING ALL N"T" BY ZERO.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:397: \${COMPILE} -x prog.cob"
echo pic-n.at:397 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:397"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:398: ./prog"
echo pic-n.at:398 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "PQRSOPQRSO" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:398"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_63
#AT_START_64
# 64. pic-n.at:402: PIC N INSPECT TALLYING
at_setup_line='pic-n.at:402'
at_desc="PIC N INSPECT TALLYING"
$at_quiet $as_echo_n " 64: $at_desc                         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "64. pic-n.at:402: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(10)  VALUE "PQRSTPQRST".
       01 CN PIC 99.
       PROCEDURE        DIVISION.
           INSPECT F0 TALLYING CN FOR ALL "ST".
           DISPLAY CN WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:417: \${COMPILE} -x prog.cob"
echo pic-n.at:417 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:417"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:418: ./prog"
echo pic-n.at:418 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "02" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:418"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_64
#AT_START_65
# 65. pic-n.at:422: PIC N Move with half-width dakuten kana.
at_setup_line='pic-n.at:422'
at_desc="PIC N Move with half-width dakuten kana."
$at_quiet $as_echo_n " 65: $at_desc       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "65. pic-n.at:422: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7).
       PROCEDURE        DIVISION.
           MOVE "ޥި" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:436: \${COMPILE} -x prog.cob"
echo pic-n.at:436 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:436"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:437: ./prog"
echo pic-n.at:437 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "J_EB\`" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:437"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_65
#AT_START_66
# 66. pic-n.at:441: PIC N Move with half-width han-dakuten kana.
at_setup_line='pic-n.at:441'
at_desc="PIC N Move with half-width han-dakuten kana."
$at_quiet $as_echo_n " 66: $at_desc   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "66. pic-n.at:441: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 F0 PIC N(7).
       PROCEDURE        DIVISION.
           MOVE "ݸ" TO F0.
           DISPLAY F0 WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:455: \${COMPILE} -x prog.cob"
echo pic-n.at:455 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:455"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/pic-n.at:456: ./prog"
echo pic-n.at:456 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "K|fO" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/pic-n.at:456"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_66
#AT_START_67
# 67. program-id.at:1: PROGRAM-ID NATIONAL C89 no warning
at_setup_line='program-id.at:1'
at_desc="PROGRAM-ID NATIONAL C89 no warning"
$at_quiet $as_echo_n " 67: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "67. program-id.at:1: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "default.conf"
c89-identifier-length-check: yes
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      s.
       DATA             DIVISION.
       PROCEDURE DIVISION.
           END PROGRAM s.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/program-id.at:16: \${COMPILE} -conf=test.conf -x prog.cob"
echo program-id.at:16 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/program-id.at:16"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_67
#AT_START_68
# 68. program-id.at:20: PROGRAM-ID NATIONAL C89 warning
at_setup_line='program-id.at:20'
at_desc="PROGRAM-ID NATIONAL C89 warning"
$at_quiet $as_echo_n " 68: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "68. program-id.at:20: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "default.conf"
c89-identifier-length-check: yes
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      pݍ`p.
       DATA             DIVISION.
       PROCEDURE DIVISION.
           END PROGRAM pݍ`p.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/program-id.at:35: \${COMPILE} -conf=test.conf -x prog.cob"
echo program-id.at:35 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:3: Warning: PROGRAM-ID length exceeds C89 function name limit
prog.cob:6: Warning: PROGRAM-ID length exceeds C89 function name limit
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/program-id.at:35"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_68
#AT_START_69
# 69. program-id.at:42: PROGRAM-ID NATIONAL C89 ignore
at_setup_line='program-id.at:42'
at_desc="PROGRAM-ID NATIONAL C89 ignore"
$at_quiet $as_echo_n " 69: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "69. program-id.at:42: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      pݍ`p.
       DATA             DIVISION.
       PROCEDURE DIVISION.
           END PROGRAM pݍ`p.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/program-id.at:52: \${COMPILE} -x prog.cob"
echo program-id.at:52 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/program-id.at:52"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_69
#AT_START_70
# 70. program-id.at:56: PROGRAM-ID NATIONAL 32 character no over
at_setup_line='program-id.at:56'
at_desc="PROGRAM-ID NATIONAL 32 character no over"
$at_quiet $as_echo_n " 70: $at_desc       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "70. program-id.at:56: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      
      -ĂƂȂɂʂ˂̂͂Ђӂւ.
       DATA             DIVISION.
       PROCEDURE DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/program-id.at:67: \${COMPILE} -x prog.cob"
echo program-id.at:67 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/program-id.at:67"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_70
#AT_START_71
# 71. program-id.at:71: PROGRAM-ID NATIONAL 32 character over
at_setup_line='program-id.at:71'
at_desc="PROGRAM-ID NATIONAL 32 character over"
$at_quiet $as_echo_n " 71: $at_desc          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "71. program-id.at:71: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      
      -ĂƂȂɂʂ˂̂͂Ђӂւق܂.
       DATA             DIVISION.
       PROCEDURE DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/program-id.at:82: \${COMPILE} -x prog.cob"
echo program-id.at:82 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:3: Error: User defined name must be less than 32 characters
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/program-id.at:82"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_71
#AT_START_72
# 72. error-print.at:1: undefined not message
at_setup_line='error-print.at:1'
at_desc="undefined not message"
$at_quiet $as_echo_n " 72: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "72. error-print.at:1: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       identification division.
       program-id. prog.
       data division.
       working-storage section.
       01 wk-01.
         03 wk-02  pic x(2).
         03 |OR  redefines wk-02 pic n(2).
       01 cnt  pic 9(1).
       procedure division.
          inspect |OR tallying cnt
            for characters before initial space.
          stop run.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/error-print.at:18: \${COMPILE} -x prog.cob"
echo error-print.at:18 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Error: Size of '|OR' larger than size of 'wk-02'
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/error-print.at:18"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_72
#AT_START_73
# 73. error-print.at:24: Encoding alphanumeric name item
at_setup_line='error-print.at:24'
at_desc="Encoding alphanumeric name item"
$at_quiet $as_echo_n " 73: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "73. error-print.at:24: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       PROCEDURE DIVISION.
           DISPLAY A___82A0___A.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/error-print.at:35: \${COMPILE} -x prog.cob"
echo error-print.at:35 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: 'A___82A0___A' undefined
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/error-print.at:35"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_73
#AT_START_74
# 74. error-print.at:41: Encoding national name item
at_setup_line='error-print.at:41'
at_desc="Encoding national name item"
$at_quiet $as_echo_n " 74: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "74. error-print.at:41: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       PROCEDURE DIVISION.
           DISPLAY A______A.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/error-print.at:52: \${COMPILE} -x prog.cob"
echo error-print.at:52 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: 'A______A' undefined
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/error-print.at:52"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_74
#AT_START_75
# 75. error-print.at:58: Decoding national section name
at_setup_line='error-print.at:58'
at_desc="Decoding national section name"
$at_quiet $as_echo_n " 75: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "75. error-print.at:58: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       PROCEDURE        DIVISION.
       eXg SECTION.
           MOVE 1 TO 1.
       eXgi.
           MOVE 1 TO 2.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/error-print.at:71: \${COMPILE} -x prog.cob"
echo error-print.at:71 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob: In section 'eXg':
prog.cob:7: Error: '1' undefined
prog.cob: In paragraph 'eXgi':
prog.cob:9: Error: '2' undefined
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/error-print.at:71"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_75
#AT_START_76
# 76. limits.at:1: Field length limit PIC A/VALID
at_setup_line='limits.at:1'
at_desc="Field length limit PIC A/VALID"
$at_quiet $as_echo_n " 76: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "76. limits.at:1: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC A(16777216).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:13: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:13 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:13"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_76
#AT_START_77
# 77. limits.at:17: Field length limit PIC A/TOO LONG
at_setup_line='limits.at:17'
at_desc="Field length limit PIC A/TOO LONG"
$at_quiet $as_echo_n " 77: $at_desc              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "77. limits.at:17: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC A(16777217).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:29: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:29 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: Alphabetic field cannot be larger than 16777216 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:29"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_77
#AT_START_78
# 78. limits.at:35: Field length limit PIC X/VALID
at_setup_line='limits.at:35'
at_desc="Field length limit PIC X/VALID"
$at_quiet $as_echo_n " 78: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "78. limits.at:35: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC X(16777216).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:47: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:47 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:47"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_78
#AT_START_79
# 79. limits.at:51: Field length limit PIC X/TOO LONG
at_setup_line='limits.at:51'
at_desc="Field length limit PIC X/TOO LONG"
$at_quiet $as_echo_n " 79: $at_desc              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "79. limits.at:51: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC X(16777217).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:63: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:63 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: AlphaNumeric field cannot be larger than 16777216 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:63"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_79
#AT_START_80
# 80. limits.at:69: Field length limit PIC B9/VALID
at_setup_line='limits.at:69'
at_desc="Field length limit PIC B9/VALID"
$at_quiet $as_echo_n " 80: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "80. limits.at:69: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC B9(159).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:81: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:81 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:81"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_80
#AT_START_81
# 81. limits.at:85: Field length limit PIC B9/TOO LONG
at_setup_line='limits.at:85'
at_desc="Field length limit PIC B9/TOO LONG"
$at_quiet $as_echo_n " 81: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "81. limits.at:85: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC B9(160).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:97: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:97 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: NumericEdit field cannot be larger than 160 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:97"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_81
#AT_START_82
# 82. limits.at:103: Field length limit PIC B/VALID
at_setup_line='limits.at:103'
at_desc="Field length limit PIC B/VALID"
$at_quiet $as_echo_n " 82: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "82. limits.at:103: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC B(16777216).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:115: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:115 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:115"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_82
#AT_START_83
# 83. limits.at:119: Field length limit PIC B/TOO LONG
at_setup_line='limits.at:119'
at_desc="Field length limit PIC B/TOO LONG"
$at_quiet $as_echo_n " 83: $at_desc              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "83. limits.at:119: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC B(16777217).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:131: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:131 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: AlphaNumericEdit field cannot be larger than 16777216 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:131"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_83
#AT_START_84
# 84. limits.at:137: Field length limit PIC BA/VALID
at_setup_line='limits.at:137'
at_desc="Field length limit PIC BA/VALID"
$at_quiet $as_echo_n " 84: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "84. limits.at:137: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC BA(16777215).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:149: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:149 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:149"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_84
#AT_START_85
# 85. limits.at:153: Field length limit PIC BA/TOO LONG
at_setup_line='limits.at:153'
at_desc="Field length limit PIC BA/TOO LONG"
$at_quiet $as_echo_n " 85: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "85. limits.at:153: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC BA(16777216).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:165: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:165 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: AlphaNumericEdit field cannot be larger than 16777216 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:165"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_85
#AT_START_86
# 86. limits.at:171: Field length limit PIC BX/VALID
at_setup_line='limits.at:171'
at_desc="Field length limit PIC BX/VALID"
$at_quiet $as_echo_n " 86: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "86. limits.at:171: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC BX(16777215).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:183: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:183 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:183"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_86
#AT_START_87
# 87. limits.at:187: Field length limit PIC BX/TOO LONG
at_setup_line='limits.at:187'
at_desc="Field length limit PIC BX/TOO LONG"
$at_quiet $as_echo_n " 87: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "87. limits.at:187: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-X       PIC BX(16777216).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:199: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:199 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: AlphaNumericEdit field cannot be larger than 16777216 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:199"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_87
#AT_START_88
# 88. limits.at:205: Field length limit PIC N/VALID (SJIS)
at_setup_line='limits.at:205'
at_desc="Field length limit PIC N/VALID (SJIS)"
$at_quiet $as_echo_n " 88: $at_desc          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "88. limits.at:205: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-N       PIC N(8388608).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:217: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:217 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:217"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_88
#AT_START_89
# 89. limits.at:221: Field length limit PIC N/TOO LONG (SJIS)
at_setup_line='limits.at:221'
at_desc="Field length limit PIC N/TOO LONG (SJIS)"
$at_quiet $as_echo_n " 89: $at_desc       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "89. limits.at:221: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 INVALID-N     PIC N(8388609).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:233: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:233 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: National field cannot be larger than 8388608 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:233"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_89
#AT_START_90
# 90. limits.at:239: Field length limit PIC BN/VALID (SJIS)
at_setup_line='limits.at:239'
at_desc="Field length limit PIC BN/VALID (SJIS)"
$at_quiet $as_echo_n " 90: $at_desc         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "90. limits.at:239: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 VALID-BN      PIC BN(8388607).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:251: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:251 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/limits.at:251"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_90
#AT_START_91
# 91. limits.at:255: Field length limit PIC BN/TOO LONG (SJIS)
at_setup_line='limits.at:255'
at_desc="Field length limit PIC BN/TOO LONG (SJIS)"
$at_quiet $as_echo_n " 91: $at_desc      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "91. limits.at:255: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 INVALID-BN    PIC BN(8388608).
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/limits.at:267: \${COMPILE_LIMIT_TEST} -o prog prog.cob"
echo limits.at:267 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_LIMIT_TEST} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: NationalEdit field cannot be larger than 8388608 digits
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/limits.at:267"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_91
#AT_START_92
# 92. national.at:1: FUNCTION NATIONAL single-byte
at_setup_line='national.at:1'
at_desc="FUNCTION NATIONAL single-byte"
$at_quiet $as_echo_n " 92: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "92. national.at:1: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I-STR    PIC X(5).
       01 O-STR    PIC X(10).
       PROCEDURE        DIVISION.
           MOVE "ABCDZ" TO I-STR.
           MOVE FUNCTION NATIONAL(I-STR) TO O-STR.
           DISPLAY O-STR WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:17: \${COMPILE_JP_COMPAT} -x prog.cob"
echo national.at:17 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:17"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:18: ./prog"
echo national.at:18 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "\`abcy" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:18"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_92
#AT_START_93
# 93. national.at:22: FUNCTION NATIONAL multi-byte
at_setup_line='national.at:22'
at_desc="FUNCTION NATIONAL multi-byte"
$at_quiet $as_echo_n " 93: $at_desc                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "93. national.at:22: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I-STR    PIC X(9).
       01 O-STR    PIC X(12).
       PROCEDURE        DIVISION.
           MOVE "AaCP2R" TO I-STR.
           MOVE FUNCTION NATIONAL(I-STR) TO O-STR.
           DISPLAY O-STR WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:38: \${COMPILE_JP_COMPAT} -x prog.cob"
echo national.at:38 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:38"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:39: ./prog"
echo national.at:39 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "\`abPQR" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:39"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_93
#AT_START_94
# 94. national.at:43: FUNCTION NATIONAL KIGOU-exclamation
at_setup_line='national.at:43'
at_desc="FUNCTION NATIONAL KIGOU-exclamation"
$at_quiet $as_echo_n " 94: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "94. national.at:43: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I-STR    PIC X(5).
       01 O-STR    PIC X(10).
       PROCEDURE        DIVISION.
           MOVE "!!!!!" TO I-STR.
           MOVE FUNCTION NATIONAL(I-STR) TO O-STR.
           DISPLAY O-STR WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:59: \${COMPILE_JP_COMPAT} -x prog.cob"
echo national.at:59 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:59"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:60: ./prog"
echo national.at:60 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "IIIII" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:60"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_94
#AT_START_95
# 95. national.at:64: FUNCTION NATIONAL KIGOU-yen
at_setup_line='national.at:64'
at_desc="FUNCTION NATIONAL KIGOU-yen"
$at_quiet $as_echo_n " 95: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "95. national.at:64: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I-STR    PIC X(1).
       01 O-STR    PIC X(10).
       PROCEDURE        DIVISION.
           MOVE "\" TO I-STR.
           MOVE FUNCTION NATIONAL(I-STR) TO O-STR.
           DISPLAY O-STR WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:80: \${COMPILE_JP_COMPAT} -x prog.cob"
echo national.at:80 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:80"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:81: ./prog"
echo national.at:81 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "        " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:81"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_95
#AT_START_96
# 96. national.at:85: FUNCTION NATIONAL KIGOU-plus
at_setup_line='national.at:85'
at_desc="FUNCTION NATIONAL KIGOU-plus"
$at_quiet $as_echo_n " 96: $at_desc                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "96. national.at:85: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I-STR    PIC X(2).
       01 O-STR    PIC X(10).
       PROCEDURE        DIVISION.
           MOVE "+ " TO I-STR.
           MOVE FUNCTION NATIONAL(I-STR) TO O-STR.
           DISPLAY O-STR WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:101: \${COMPILE_JP_COMPAT} -x prog.cob"
echo national.at:101 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:101"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:102: ./prog"
echo national.at:102 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "{@      " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:102"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_96
#AT_START_97
# 97. national.at:106: FUNCTION NATIONAL (HanKana w/ Daku-on)
at_setup_line='national.at:106'
at_desc="FUNCTION NATIONAL (HanKana w/ Daku-on)"
$at_quiet $as_echo_n " 97: $at_desc         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "97. national.at:106: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I-STR    PIC X(16).
       01 O-STR    PIC X(16).
       PROCEDURE        DIVISION.
           MOVE "ި޶" TO I-STR.
           MOVE FUNCTION NATIONAL(I-STR) TO O-STR.
           DISPLAY O-STR WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:122: \${COMPILE_JP_COMPAT} -x prog.cob"
echo national.at:122 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:122"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:123: ./prog"
echo national.at:123 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "fBKK@@@" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:123"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_97
#AT_START_98
# 98. national.at:127: FUNCTION NATIONAL (HanKana w/ Han-daku-on)
at_setup_line='national.at:127'
at_desc="FUNCTION NATIONAL (HanKana w/ Han-daku-on)"
$at_quiet $as_echo_n " 98: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "98. national.at:127: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I-STR    PIC X(10).
       01 O-STR    PIC X(10).
       PROCEDURE        DIVISION.
           MOVE "" TO I-STR.
           MOVE FUNCTION NATIONAL(I-STR) TO O-STR.
           DISPLAY O-STR WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:143: \${COMPILE_JP_COMPAT} -x prog.cob"
echo national.at:143 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_JP_COMPAT} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:143"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:144: ./prog"
echo national.at:144 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "|s@@" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:144"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_98
#AT_START_99
# 99. national.at:148: N Literal (NO zenakaku conversion)
at_setup_line='national.at:148'
at_desc="N Literal (NO zenakaku conversion)"
$at_quiet $as_echo_n " 99: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "99. national.at:148: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY N"".
           DISPLAY N"".
           DISPLAY N"".
           DISPLAY N"ABC".
           DISPLAY N"#$%".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:162: \${COMPILE} -x prog.cob"
echo national.at:162 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:162"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:163: ./prog"
echo national.at:163 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "


ABC
#\$%
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:163"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_99
#AT_START_100
# 100. national.at:173: NC Literal (NO zenakaku conversion)
at_setup_line='national.at:173'
at_desc="NC Literal (NO zenakaku conversion)"
$at_quiet $as_echo_n "100: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "100. national.at:173: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY NC"".
           DISPLAY NC"".
           DISPLAY NC"".
           DISPLAY NC"ABC".
           DISPLAY NC"#$%".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:187: \${COMPILE} -x prog.cob"
echo national.at:187 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:187"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:188: ./prog"
echo national.at:188 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "


ABC
#\$%
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:188"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_100
#AT_START_101
# 101. national.at:198: ND Literal (NO zenakaku conversion)
at_setup_line='national.at:198'
at_desc="ND Literal (NO zenakaku conversion)"
$at_quiet $as_echo_n "101: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "101. national.at:198: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY ND"".
           DISPLAY ND"".
           DISPLAY ND"".
           DISPLAY ND"ABC".
           DISPLAY ND"#$%".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:212: \${COMPILE} -x prog.cob"
echo national.at:212 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:212"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:213: ./prog"
echo national.at:213 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "


ABC
#\$%
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:213"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_101
#AT_START_102
# 102. national.at:223: NX Literal
at_setup_line='national.at:223'
at_desc="NX Literal"
$at_quiet $as_echo_n "102: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "102. national.at:223: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY NX"82A282EB82CD".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/national.at:233: \${COMPILE} -x prog.cob"
echo national.at:233 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:233"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/national.at:234: ./prog"
echo national.at:234 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/national.at:234"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_102
#AT_START_103
# 103. mb-space.at:1: Zenkaku SPC delims in headings
at_setup_line='mb-space.at:1'
at_desc="Zenkaku SPC delims in headings"
$at_quiet $as_echo_n "103: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "103. mb-space.at:1: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION@DIVISION.
       PROGRAM-ID.      prog.
       DATA @@@@@ DIVISION.
       WORKING-STORAGE@ SECTION.
       01  PIC X.
       PROCEDURE @@DIVISION.
           DISPLAY "OK" WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/mb-space.at:14: \${COMPILE} -x prog.cob"
echo mb-space.at:14 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/mb-space.at:14"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/mb-space.at:15: ./prog"
echo mb-space.at:15 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/mb-space.at:15"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_103
#AT_START_104
# 104. mb-space.at:19: Zenkaku SPC delims in record def
at_setup_line='mb-space.at:19'
at_desc="Zenkaku SPC delims in record def"
$at_quiet $as_echo_n "104: $at_desc               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "104. mb-space.at:19: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 ځ@PIC X(40) VALUE
          "Zen SPC between item name and PIC clause".
@     01  F00 PIC X.
  @   01  F01 PIC X.
       01@F02 PIC X.
       01@F03 PIC@X.
       01@F04 PIC X@.
       PROCEDURE        DIVISION.
           DISPLAY  WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/mb-space.at:38: \${COMPILE} -x prog.cob"
echo mb-space.at:38 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/mb-space.at:38"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/mb-space.at:39: ./prog"
echo mb-space.at:39 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Zen SPC between item name and PIC clause" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/mb-space.at:39"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_104
#AT_START_105
# 105. mb-space.at:43: Zenkaku SPC delims in COPY stmt
at_setup_line='mb-space.at:43'
at_desc="Zenkaku SPC delims in COPY stmt"
$at_quiet $as_echo_n "105: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "105. mb-space.at:43: testing ..."
  $at_traceon


cat >inc.cpy <<'_ATEOF'

       01 ځ@PIC X(2) VALUE "OK".
@     01  F00 PIC X.
  @   01  F01 PIC X.
       01@F02 PIC X.
       01@F03 PIC@X.
       01@F04 PIC X@.
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       COPY @inc.
       PROCEDURE        DIVISION.
           DISPLAY  WITH NO ADVANCING.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/mb-space.at:65: \${COMPILE} -x prog.cob"
echo mb-space.at:65 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -x prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/mb-space.at:65"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/mb-space.at:66: ./prog"
echo mb-space.at:66 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/mb-space.at:66"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_105
