# Makefile generated by imake - do not edit!
# $XConsortium: imake.c,v 1.48 89/10/10 18:33:21 jim Exp $

CPU_TYPE = mips

PREFIX = /proj
INSTALL_PREFIX = $(PREFIX)

BIN = mips/bin
BIN_USE     = $(PREFIX)/$(BIN)
BIN_INSTALL = $(INSTALL_PREFIX)/$(BIN)

PUB = m3/pub.mips
PUB_USE     = $(PREFIX)/$(PUB)
PUB_INSTALL = $(INSTALL_PREFIX)/$(PUB)

LIB = m3/lib.mips
LIB_USE     = $(PREFIX)/$(LIB)
LIB_INSTALL = $(INSTALL_PREFIX)/$(LIB)

GNUEMACS_INSTALL = $(INSTALL_PREFIX)/generic/lib

MAN = man/mips
MAN_USE  = $(PREFIX)/$(MAN)
MAN_INSTALL = $(INSTALL_PREFIX)/$(MAN)

XLIBPATH = /usr/local/lib
XLIB     = -lX11

CC = cc

CC_WARNS_FOR_UNKNOWN_FILES = 0

CC_G = @-g2@

CC_O = @-O2@

KEEP_LIBRARIES_RESOLVED = 1

CFLAGS =

M3OPT = -g

BOOTOPT = -g

IMAKEFLAGS =

SHELL = /bin/sh

CPP = /lib/cpp

MAKE = make

SEP   = @
PASS0 = @$(LIB_USE)/m3compiler@
PASS1 = @cc@-G@0@-Wf,-XNp200000@-Wf,-XNd150000@
PASS2 = @cc@-G@0@
PASS3 = @/bin/ar@cru@
PASS4 = @ranlib@
PASS5 = @/bin/ld@-A@
OVERLAY_0 = @-G@0@-g2@
OVERLAY_1 = @-lc_G0@
BASE_ARGS = @-N@

SERVER_LIMIT = 0

DEFPATH = .:$(PUB_USE)

LIBPATH = .:$(LIB_USE):$(XLIBPATH)

LINKBFILES = @-lm@
LINKFILES = @-lm3@-lm@

LINKCOVER  = $(LIB_USE)/report_coverage.o

INCL = $(LIB_USE)

TEMPLATE = toplevel.tmpl.SRC

all::

M3        = $(BIN_USE)/m3

M3FLAGS   = -w1 -make -why
M3DEFPATH =
M3LIBPATH =
DO_M3     = $(M3) $(M3FLAGS) $(M3OPT) $(M3OPTIONS) $(M3DEFPATH) $(M3LIBPATH)

X11LIBS   = -L$(XLIBPATH) -lXaw -lXmu -lXext -lXt $(XLIB)
M3X11LIBS = -lm3X11R4 $(X11LIBS)
UILIB = -lm3ui -lm3X11R4 $(XLIB)
FORMSVBTLIB = -lm3formsvbt -lm3vbtkit $(UILIB)
ZEUSLIB = -lm3mgkit -lm3mg -lm3zeus -lm3codeview $(FORMSVBTLIB)

all:: .pkgs

.pkgs:: $(M3MAKEFILE) ;\
  @echo "building import links..." ;\
  rm -rf .pkgs ;\
  mkdir .pkgs ;\
  pkgnames="$(PACKAGES)" ;\
  for PKG in $$pkgnames; do (\
     echo "   " $$PKG ;\
     $(LIB_USE)/m3mkpath .pkgs/$$PKG ;\
     rm -f .pkgs/$$PKG ;\
     ln -s  /proj/m3/pkg/$$PKG .pkgs/$$PKG \
  ); done

TANGLEFLAGS = -L'<*LINE %L "%F" *>%N'
WEAVEFLAGS = -n

COMPILE = $(M3) -c -g -k -w1 -D../.. -nostd

all::
new_base::
tidy::
scratch::

all:: c001_X
new_base:: c001_base
scratch:: ; -rm -fr c001_X
c001:: c001_X
c001_base:: c001_X ; @mv c001_X/stdout c001_X/stderr c001
c001_X:: FRC ;\
-@ echo --- c001 ---  "empty program"  ;\
   rm -fr c001_X ;\
   mkdir c001_X ;\
   (cd c001_X ; $(COMPILE) ../c001 >stdout ) 1>2 2>c001_X/stderr ;\
   if test -r c001/stdout;\
     then diff c001/stdout c001_X/stdout;\
     else cat c001_X/stdout;\
   fi;\
   if test -r c001/stderr;\
     then diff c001/stderr c001_X/stderr;\
     else cat c001_X/stderr;\
   fi;\
   rm -f c001_X/a.out

all:: c002_X
new_base:: c002_base
scratch:: ; -rm -fr c002_X
c002:: c002_X
c002_base:: c002_X ; @mv c002_X/stdout c002_X/stderr c002
c002_X:: FRC ;\
-@ echo --- c002 ---  "empty unsafe program"  ;\
   rm -fr c002_X ;\
   mkdir c002_X ;\
   (cd c002_X ; $(COMPILE) ../c002 >stdout ) 1>2 2>c002_X/stderr ;\
   if test -r c002/stdout;\
     then diff c002/stdout c002_X/stdout;\
     else cat c002_X/stdout;\
   fi;\
   if test -r c002/stderr;\
     then diff c002/stderr c002_X/stderr;\
     else cat c002_X/stderr;\
   fi;\
   rm -f c002_X/a.out

all:: c003_X
new_base:: c003_base
scratch:: ; -rm -fr c003_X
c003:: c003_X
c003_base:: c003_X ; @mv c003_X/stdout c003_X/stderr c003
c003_X:: FRC ;\
-@ echo --- c003 ---  "a program with two statements"  ;\
   rm -fr c003_X ;\
   mkdir c003_X ;\
   (cd c003_X ; $(COMPILE) ../c003 >stdout ) 1>2 2>c003_X/stderr ;\
   if test -r c003/stdout;\
     then diff c003/stdout c003_X/stdout;\
     else cat c003_X/stdout;\
   fi;\
   if test -r c003/stderr;\
     then diff c003/stderr c003_X/stderr;\
     else cat c003_X/stderr;\
   fi;\
   rm -f c003_X/a.out

all:: c004_X
new_base:: c004_base
scratch:: ; -rm -fr c004_X
c004:: c004_X
c004_base:: c004_X ; @mv c004_X/stdout c004_X/stderr c004
c004_X:: FRC ;\
-@ echo --- c004 ---  "declaration of REF INTEGER"  ;\
   rm -fr c004_X ;\
   mkdir c004_X ;\
   (cd c004_X ; $(COMPILE) ../c004 >stdout ) 1>2 2>c004_X/stderr ;\
   if test -r c004/stdout;\
     then diff c004/stdout c004_X/stdout;\
     else cat c004_X/stdout;\
   fi;\
   if test -r c004/stderr;\
     then diff c004/stderr c004_X/stderr;\
     else cat c004_X/stderr;\
   fi;\
   rm -f c004_X/a.out

all:: c005_X
new_base:: c005_base
scratch:: ; -rm -fr c005_X
c005:: c005_X
c005_base:: c005_X ; @mv c005_X/stdout c005_X/stderr c005
c005_X:: FRC ;\
-@ echo --- c005 ---  "declaration of T subtype REFANY"  ;\
   rm -fr c005_X ;\
   mkdir c005_X ;\
   (cd c005_X ; $(COMPILE) ../c005 >stdout ) 1>2 2>c005_X/stderr ;\
   if test -r c005/stdout;\
     then diff c005/stdout c005_X/stdout;\
     else cat c005_X/stdout;\
   fi;\
   if test -r c005/stderr;\
     then diff c005/stderr c005_X/stderr;\
     else cat c005_X/stderr;\
   fi;\
   rm -f c005_X/a.out

all:: c006_X
new_base:: c006_base
scratch:: ; -rm -fr c006_X
c006:: c006_X
c006_base:: c006_X ; @mv c006_X/stdout c006_X/stderr c006
c006_X:: FRC ;\
-@ echo --- c006 ---  "variables in nested blocks and procedures"  ;\
   rm -fr c006_X ;\
   mkdir c006_X ;\
   (cd c006_X ; $(COMPILE) ../c006 >stdout ) 1>2 2>c006_X/stderr ;\
   if test -r c006/stdout;\
     then diff c006/stdout c006_X/stdout;\
     else cat c006_X/stdout;\
   fi;\
   if test -r c006/stderr;\
     then diff c006/stderr c006_X/stderr;\
     else cat c006_X/stderr;\
   fi;\
   rm -f c006_X/a.out

all:: c007_X
new_base:: c007_base
scratch:: ; -rm -fr c007_X
c007:: c007_X
c007_base:: c007_X ; @mv c007_X/stdout c007_X/stderr c007
c007_X:: FRC ;\
-@ echo --- c007 ---  "a procedure with an integer argument"  ;\
   rm -fr c007_X ;\
   mkdir c007_X ;\
   (cd c007_X ; $(COMPILE) ../c007 >stdout ) 1>2 2>c007_X/stderr ;\
   if test -r c007/stdout;\
     then diff c007/stdout c007_X/stdout;\
     else cat c007_X/stdout;\
   fi;\
   if test -r c007/stderr;\
     then diff c007/stderr c007_X/stderr;\
     else cat c007_X/stderr;\
   fi;\
   rm -f c007_X/a.out

all:: c008_X
new_base:: c008_base
scratch:: ; -rm -fr c008_X
c008:: c008_X
c008_base:: c008_X ; @mv c008_X/stdout c008_X/stderr c008
c008_X:: FRC ;\
-@ echo --- c008 ---  "CASE statements"  ;\
   rm -fr c008_X ;\
   mkdir c008_X ;\
   (cd c008_X ; $(COMPILE) ../c008 >stdout ) 1>2 2>c008_X/stderr ;\
   if test -r c008/stdout;\
     then diff c008/stdout c008_X/stdout;\
     else cat c008_X/stdout;\
   fi;\
   if test -r c008/stderr;\
     then diff c008/stderr c008_X/stderr;\
     else cat c008_X/stderr;\
   fi;\
   rm -f c008_X/a.out

all:: c009_X
new_base:: c009_base
scratch:: ; -rm -fr c009_X
c009:: c009_X
c009_base:: c009_X ; @mv c009_X/stdout c009_X/stderr c009
c009_X:: FRC ;\
-@ echo --- c009 ---  "FOR and EXIT statements"  ;\
   rm -fr c009_X ;\
   mkdir c009_X ;\
   (cd c009_X ; $(COMPILE) ../c009 >stdout ) 1>2 2>c009_X/stderr ;\
   if test -r c009/stdout;\
     then diff c009/stdout c009_X/stdout;\
     else cat c009_X/stdout;\
   fi;\
   if test -r c009/stderr;\
     then diff c009/stderr c009_X/stderr;\
     else cat c009_X/stderr;\
   fi;\
   rm -f c009_X/a.out

all:: c010_X
new_base:: c010_base
scratch:: ; -rm -fr c010_X
c010:: c010_X
c010_base:: c010_X ; @mv c010_X/stdout c010_X/stderr c010
c010_X:: FRC ;\
-@ echo --- c010 ---  "IF statements"  ;\
   rm -fr c010_X ;\
   mkdir c010_X ;\
   (cd c010_X ; $(COMPILE) ../c010 >stdout ) 1>2 2>c010_X/stderr ;\
   if test -r c010/stdout;\
     then diff c010/stdout c010_X/stdout;\
     else cat c010_X/stdout;\
   fi;\
   if test -r c010/stderr;\
     then diff c010/stderr c010_X/stderr;\
     else cat c010_X/stderr;\
   fi;\
   rm -f c010_X/a.out

all:: c011_X
new_base:: c011_base
scratch:: ; -rm -fr c011_X
c011:: c011_X
c011_base:: c011_X ; @mv c011_X/stdout c011_X/stderr c011
c011_X:: FRC ;\
-@ echo --- c011 ---  "address substraction"  ;\
   rm -fr c011_X ;\
   mkdir c011_X ;\
   (cd c011_X ; $(COMPILE) ../c011 >stdout ) 1>2 2>c011_X/stderr ;\
   if test -r c011/stdout;\
     then diff c011/stdout c011_X/stdout;\
     else cat c011_X/stdout;\
   fi;\
   if test -r c011/stderr;\
     then diff c011/stderr c011_X/stderr;\
     else cat c011_X/stderr;\
   fi;\
   rm -f c011_X/a.out

all:: c012_X
new_base:: c012_base
scratch:: ; -rm -fr c012_X
c012:: c012_X
c012_base:: c012_X ; @mv c012_X/stdout c012_X/stderr c012
c012_X:: FRC ;\
-@ echo --- c012 ---  "LOOP and EXIT statements"  ;\
   rm -fr c012_X ;\
   mkdir c012_X ;\
   (cd c012_X ; $(COMPILE) ../c012 >stdout ) 1>2 2>c012_X/stderr ;\
   if test -r c012/stdout;\
     then diff c012/stdout c012_X/stdout;\
     else cat c012_X/stdout;\
   fi;\
   if test -r c012/stderr;\
     then diff c012/stderr c012_X/stderr;\
     else cat c012_X/stderr;\
   fi;\
   rm -f c012_X/a.out

all:: c013_X
new_base:: c013_base
scratch:: ; -rm -fr c013_X
c013:: c013_X
c013_base:: c013_X ; @mv c013_X/stdout c013_X/stderr c013
c013_X:: FRC ;\
-@ echo --- c013 ---  "REPEAT and EXIT statements"  ;\
   rm -fr c013_X ;\
   mkdir c013_X ;\
   (cd c013_X ; $(COMPILE) ../c013 >stdout ) 1>2 2>c013_X/stderr ;\
   if test -r c013/stdout;\
     then diff c013/stdout c013_X/stdout;\
     else cat c013_X/stdout;\
   fi;\
   if test -r c013/stderr;\
     then diff c013/stderr c013_X/stderr;\
     else cat c013_X/stderr;\
   fi;\
   rm -f c013_X/a.out

all:: c014_X
new_base:: c014_base
scratch:: ; -rm -fr c014_X
c014:: c014_X
c014_base:: c014_X ; @mv c014_X/stdout c014_X/stderr c014
c014_X:: FRC ;\
-@ echo --- c014 ---  "TRY FINALLY and RETURN statements"  ;\
   rm -fr c014_X ;\
   mkdir c014_X ;\
   (cd c014_X ; $(COMPILE) ../c014 >stdout ) 1>2 2>c014_X/stderr ;\
   if test -r c014/stdout;\
     then diff c014/stdout c014_X/stdout;\
     else cat c014_X/stdout;\
   fi;\
   if test -r c014/stderr;\
     then diff c014/stderr c014_X/stderr;\
     else cat c014_X/stderr;\
   fi;\
   rm -f c014_X/a.out

all:: c015_X
new_base:: c015_base
scratch:: ; -rm -fr c015_X
c015:: c015_X
c015_base:: c015_X ; @mv c015_X/stdout c015_X/stderr c015
c015_X:: FRC ;\
-@ echo --- c015 ---  "imbricated TRY FINALLY statements"  ;\
   rm -fr c015_X ;\
   mkdir c015_X ;\
   (cd c015_X ; $(COMPILE) ../c015 >stdout ) 1>2 2>c015_X/stderr ;\
   if test -r c015/stdout;\
     then diff c015/stdout c015_X/stdout;\
     else cat c015_X/stdout;\
   fi;\
   if test -r c015/stderr;\
     then diff c015/stderr c015_X/stderr;\
     else cat c015_X/stderr;\
   fi;\
   rm -f c015_X/a.out

all:: c016_X
new_base:: c016_base
scratch:: ; -rm -fr c016_X
c016:: c016_X
c016_base:: c016_X ; @mv c016_X/stdout c016_X/stderr c016
c016_X:: FRC ;\
-@ echo --- c016 ---  "TRY EXCEPT statements"  ;\
   rm -fr c016_X ;\
   mkdir c016_X ;\
   (cd c016_X ; $(COMPILE) ../c016 >stdout ) 1>2 2>c016_X/stderr ;\
   if test -r c016/stdout;\
     then diff c016/stdout c016_X/stdout;\
     else cat c016_X/stdout;\
   fi;\
   if test -r c016/stderr;\
     then diff c016/stderr c016_X/stderr;\
     else cat c016_X/stderr;\
   fi;\
   rm -f c016_X/a.out

all:: c017_X
new_base:: c017_base
scratch:: ; -rm -fr c017_X
c017:: c017_X
c017_base:: c017_X ; @mv c017_X/stdout c017_X/stderr c017
c017_X:: FRC ;\
-@ echo --- c017 ---  "TYPECASE statements"  ;\
   rm -fr c017_X ;\
   mkdir c017_X ;\
   (cd c017_X ; $(COMPILE) ../c017 >stdout ) 1>2 2>c017_X/stderr ;\
   if test -r c017/stdout;\
     then diff c017/stdout c017_X/stdout;\
     else cat c017_X/stdout;\
   fi;\
   if test -r c017/stderr;\
     then diff c017/stderr c017_X/stderr;\
     else cat c017_X/stderr;\
   fi;\
   rm -f c017_X/a.out

all:: c018_X
new_base:: c018_base
scratch:: ; -rm -fr c018_X
c018:: c018_X
c018_base:: c018_X ; @mv c018_X/stdout c018_X/stderr c018
c018_X:: FRC ;\
-@ echo --- c018 ---  "WHILE and EXIT statements"  ;\
   rm -fr c018_X ;\
   mkdir c018_X ;\
   (cd c018_X ; $(COMPILE) ../c018 >stdout ) 1>2 2>c018_X/stderr ;\
   if test -r c018/stdout;\
     then diff c018/stdout c018_X/stdout;\
     else cat c018_X/stdout;\
   fi;\
   if test -r c018/stderr;\
     then diff c018/stderr c018_X/stderr;\
     else cat c018_X/stderr;\
   fi;\
   rm -f c018_X/a.out

all:: c019_X
new_base:: c019_base
scratch:: ; -rm -fr c019_X
c019:: c019_X
c019_base:: c019_X ; @mv c019_X/stdout c019_X/stderr c019
c019_X:: FRC ;\
-@ echo --- c019 ---  "WITH statements"  ;\
   rm -fr c019_X ;\
   mkdir c019_X ;\
   (cd c019_X ; $(COMPILE) ../c019 >stdout ) 1>2 2>c019_X/stderr ;\
   if test -r c019/stdout;\
     then diff c019/stdout c019_X/stdout;\
     else cat c019_X/stdout;\
   fi;\
   if test -r c019/stderr;\
     then diff c019/stderr c019_X/stderr;\
     else cat c019_X/stderr;\
   fi;\
   rm -f c019_X/a.out

all:: c020_X
new_base:: c020_base
scratch:: ; -rm -fr c020_X
c020:: c020_X
c020_base:: c020_X ; @mv c020_X/stdout c020_X/stderr c020
c020_X:: FRC ;\
-@ echo --- c020 ---  "assignment of INTEGER subranges"  ;\
   rm -fr c020_X ;\
   mkdir c020_X ;\
   (cd c020_X ; $(COMPILE) ../c020 >stdout ) 1>2 2>c020_X/stderr ;\
   if test -r c020/stdout;\
     then diff c020/stdout c020_X/stdout;\
     else cat c020_X/stdout;\
   fi;\
   if test -r c020/stderr;\
     then diff c020/stderr c020_X/stderr;\
     else cat c020_X/stderr;\
   fi;\
   rm -f c020_X/a.out

all:: c021_X
new_base:: c021_base
scratch:: ; -rm -fr c021_X
c021:: c021_X
c021_base:: c021_X ; @mv c021_X/stdout c021_X/stderr c021
c021_X:: FRC ;\
-@ echo --- c021 ---  "procedures and variables in an Interface"  ;\
   rm -fr c021_X ;\
   mkdir c021_X ;\
   (cd c021_X ; $(COMPILE) ../c021 >stdout ) 1>2 2>c021_X/stderr ;\
   if test -r c021/stdout;\
     then diff c021/stdout c021_X/stdout;\
     else cat c021_X/stdout;\
   fi;\
   if test -r c021/stderr;\
     then diff c021/stderr c021_X/stderr;\
     else cat c021_X/stderr;\
   fi;\
   rm -f c021_X/a.out

all:: c022_X
new_base:: c022_base
scratch:: ; -rm -fr c022_X
c022:: c022_X
c022_base:: c022_X ; @mv c022_X/stdout c022_X/stderr c022
c022_X:: FRC ;\
-@ echo --- c022 ---  "user and language specified variable initialization"  ;\
   rm -fr c022_X ;\
   mkdir c022_X ;\
   (cd c022_X ; $(COMPILE) ../c022 >stdout ) 1>2 2>c022_X/stderr ;\
   if test -r c022/stdout;\
     then diff c022/stdout c022_X/stdout;\
     else cat c022_X/stdout;\
   fi;\
   if test -r c022/stderr;\
     then diff c022/stderr c022_X/stderr;\
     else cat c022_X/stderr;\
   fi;\
   rm -f c022_X/a.out

all:: c023_X
new_base:: c023_base
scratch:: ; -rm -fr c023_X
c023:: c023_X
c023_base:: c023_X ; @mv c023_X/stdout c023_X/stderr c023
c023_X:: FRC ;\
-@ echo --- c023 ---  "simple subrange type in an Interface"  ;\
   rm -fr c023_X ;\
   mkdir c023_X ;\
   (cd c023_X ; $(COMPILE) ../c023 >stdout ) 1>2 2>c023_X/stderr ;\
   if test -r c023/stdout;\
     then diff c023/stdout c023_X/stdout;\
     else cat c023_X/stdout;\
   fi;\
   if test -r c023/stderr;\
     then diff c023/stderr c023_X/stderr;\
     else cat c023_X/stderr;\
   fi;\
   rm -f c023_X/a.out

all:: c024_X
new_base:: c024_base
scratch:: ; -rm -fr c024_X
c024:: c024_X
c024_base:: c024_X ; @mv c024_X/stdout c024_X/stderr c024
c024_X:: FRC ;\
-@ echo --- c024 ---  "importing an external subrange type"  ;\
   rm -fr c024_X ;\
   mkdir c024_X ;\
   (cd c024_X ; $(COMPILE) ../c024 >stdout ) 1>2 2>c024_X/stderr ;\
   if test -r c024/stdout;\
     then diff c024/stdout c024_X/stdout;\
     else cat c024_X/stdout;\
   fi;\
   if test -r c024/stderr;\
     then diff c024/stderr c024_X/stderr;\
     else cat c024_X/stderr;\
   fi;\
   rm -f c024_X/a.out

all:: c025_X
new_base:: c025_base
scratch:: ; -rm -fr c025_X
c025:: c025_X
c025_base:: c025_X ; @mv c025_X/stdout c025_X/stderr c025
c025_X:: FRC ;\
-@ echo --- c025 ---  "RECORD types variables and assignments"  ;\
   rm -fr c025_X ;\
   mkdir c025_X ;\
   (cd c025_X ; $(COMPILE) ../c025 >stdout ) 1>2 2>c025_X/stderr ;\
   if test -r c025/stdout;\
     then diff c025/stdout c025_X/stdout;\
     else cat c025_X/stdout;\
   fi;\
   if test -r c025/stderr;\
     then diff c025/stderr c025_X/stderr;\
     else cat c025_X/stderr;\
   fi;\
   rm -f c025_X/a.out

all:: c026_X
new_base:: c026_base
scratch:: ; -rm -fr c026_X
c026:: c026_X
c026_base:: c026_X ; @mv c026_X/stdout c026_X/stderr c026
c026_X:: FRC ;\
-@ echo --- c026 ---  "fixed ARRAY types variables assignments and subscripting"  ;\
   rm -fr c026_X ;\
   mkdir c026_X ;\
   (cd c026_X ; $(COMPILE) ../c026 >stdout ) 1>2 2>c026_X/stderr ;\
   if test -r c026/stdout;\
     then diff c026/stdout c026_X/stdout;\
     else cat c026_X/stdout;\
   fi;\
   if test -r c026/stderr;\
     then diff c026/stderr c026_X/stderr;\
     else cat c026_X/stderr;\
   fi;\
   rm -f c026_X/a.out

all:: c027_X
new_base:: c027_base
scratch:: ; -rm -fr c027_X
c027:: c027_X
c027_base:: c027_X ; @mv c027_X/stdout c027_X/stderr c027
c027_X:: FRC ;\
-@ echo --- c027 ---  "nested procedures with up-level variable references"  ;\
   rm -fr c027_X ;\
   mkdir c027_X ;\
   (cd c027_X ; $(COMPILE) ../c027 >stdout ) 1>2 2>c027_X/stderr ;\
   if test -r c027/stdout;\
     then diff c027/stdout c027_X/stdout;\
     else cat c027_X/stdout;\
   fi;\
   if test -r c027/stderr;\
     then diff c027/stderr c027_X/stderr;\
     else cat c027_X/stderr;\
   fi;\
   rm -f c027_X/a.out

all:: c028_X
new_base:: c028_base
scratch:: ; -rm -fr c028_X
c028:: c028_X
c028_base:: c028_X ; @mv c028_X/stdout c028_X/stderr c028
c028_X:: FRC ;\
-@ echo --- c028 ---  "type minimization of REF/RECORD"  ;\
   rm -fr c028_X ;\
   mkdir c028_X ;\
   (cd c028_X ; $(COMPILE) ../c028 >stdout ) 1>2 2>c028_X/stderr ;\
   if test -r c028/stdout;\
     then diff c028/stdout c028_X/stdout;\
     else cat c028_X/stdout;\
   fi;\
   if test -r c028/stderr;\
     then diff c028/stderr c028_X/stderr;\
     else cat c028_X/stderr;\
   fi;\
   rm -f c028_X/a.out

all:: c029_X
new_base:: c029_base
scratch:: ; -rm -fr c029_X
c029:: c029_X
c029_base:: c029_X ; @mv c029_X/stdout c029_X/stderr c029
c029_X:: FRC ;\
-@ echo --- c029 ---  "non-opaque OBJECTs"  ;\
   rm -fr c029_X ;\
   mkdir c029_X ;\
   (cd c029_X ; $(COMPILE) ../c029 >stdout ) 1>2 2>c029_X/stderr ;\
   if test -r c029/stdout;\
     then diff c029/stdout c029_X/stdout;\
     else cat c029_X/stdout;\
   fi;\
   if test -r c029/stderr;\
     then diff c029/stderr c029_X/stderr;\
     else cat c029_X/stderr;\
   fi;\
   rm -f c029_X/a.out

all:: c030_X
new_base:: c030_base
scratch:: ; -rm -fr c030_X
c030:: c030_X
c030_base:: c030_X ; @mv c030_X/stdout c030_X/stderr c030
c030_X:: FRC ;\
-@ echo --- c030 ---  "opaque OBJECTS"  ;\
   rm -fr c030_X ;\
   mkdir c030_X ;\
   (cd c030_X ; $(COMPILE) ../c030 >stdout ) 1>2 2>c030_X/stderr ;\
   if test -r c030/stdout;\
     then diff c030/stdout c030_X/stdout;\
     else cat c030_X/stdout;\
   fi;\
   if test -r c030/stderr;\
     then diff c030/stderr c030_X/stderr;\
     else cat c030_X/stderr;\
   fi;\
   rm -f c030_X/a.out

all:: c031_X
new_base:: c031_base
scratch:: ; -rm -fr c031_X
c031:: c031_X
c031_base:: c031_X ; @mv c031_X/stdout c031_X/stderr c031
c031_X:: FRC ;\
-@ echo --- c031 ---  "assignment and initialization of INTEGER subranges"  ;\
   rm -fr c031_X ;\
   mkdir c031_X ;\
   (cd c031_X ; $(COMPILE) ../c031 >stdout ) 1>2 2>c031_X/stderr ;\
   if test -r c031/stdout;\
     then diff c031/stdout c031_X/stdout;\
     else cat c031_X/stdout;\
   fi;\
   if test -r c031/stderr;\
     then diff c031/stderr c031_X/stderr;\
     else cat c031_X/stderr;\
   fi;\
   rm -f c031_X/a.out

all:: c032_X
new_base:: c032_base
scratch:: ; -rm -fr c032_X
c032:: c032_X
c032_base:: c032_X ; @mv c032_X/stdout c032_X/stderr c032
c032_X:: FRC ;\
-@ echo --- c032 ---  "BRANDED REF types"  ;\
   rm -fr c032_X ;\
   mkdir c032_X ;\
   (cd c032_X ; $(COMPILE) ../c032 >stdout ) 1>2 2>c032_X/stderr ;\
   if test -r c032/stdout;\
     then diff c032/stdout c032_X/stdout;\
     else cat c032_X/stdout;\
   fi;\
   if test -r c032/stderr;\
     then diff c032/stderr c032_X/stderr;\
     else cat c032_X/stderr;\
   fi;\
   rm -f c032_X/a.out

all:: c033_X
new_base:: c033_base
scratch:: ; -rm -fr c033_X
c033:: c033_X
c033_base:: c033_X ; @mv c033_X/stdout c033_X/stderr c033
c033_X:: FRC ;\
-@ echo --- c033 ---  "NEW of simple REF types"  ;\
   rm -fr c033_X ;\
   mkdir c033_X ;\
   (cd c033_X ; $(COMPILE) ../c033 >stdout ) 1>2 2>c033_X/stderr ;\
   if test -r c033/stdout;\
     then diff c033/stdout c033_X/stdout;\
     else cat c033_X/stdout;\
   fi;\
   if test -r c033/stderr;\
     then diff c033/stderr c033_X/stderr;\
     else cat c033_X/stderr;\
   fi;\
   rm -f c033_X/a.out

all:: c034_X
new_base:: c034_base
scratch:: ; -rm -fr c034_X
c034:: c034_X
c034_base:: c034_X ; @mv c034_X/stdout c034_X/stderr c034
c034_X:: FRC ;\
-@ echo --- c034 ---  "NEW of REF types that require initialization"  ;\
   rm -fr c034_X ;\
   mkdir c034_X ;\
   (cd c034_X ; $(COMPILE) ../c034 >stdout ) 1>2 2>c034_X/stderr ;\
   if test -r c034/stdout;\
     then diff c034/stdout c034_X/stdout;\
     else cat c034_X/stdout;\
   fi;\
   if test -r c034/stderr;\
     then diff c034/stderr c034_X/stderr;\
     else cat c034_X/stderr;\
   fi;\
   rm -f c034_X/a.out

all:: c035_X
new_base:: c035_base
scratch:: ; -rm -fr c035_X
c035:: c035_X
c035_base:: c035_X ; @mv c035_X/stdout c035_X/stderr c035
c035_X:: FRC ;\
-@ echo --- c035 ---  "NEW of open arrays"  ;\
   rm -fr c035_X ;\
   mkdir c035_X ;\
   (cd c035_X ; $(COMPILE) ../c035 >stdout ) 1>2 2>c035_X/stderr ;\
   if test -r c035/stdout;\
     then diff c035/stdout c035_X/stdout;\
     else cat c035_X/stdout;\
   fi;\
   if test -r c035/stderr;\
     then diff c035/stderr c035_X/stderr;\
     else cat c035_X/stderr;\
   fi;\
   rm -f c035_X/a.out

all:: c036_X
new_base:: c036_base
scratch:: ; -rm -fr c036_X
c036:: c036_X
c036_base:: c036_X ; @mv c036_X/stdout c036_X/stderr c036
c036_X:: FRC ;\
-@ echo --- c036 ---  "NEW of OBJECTs with default and non-default slots"  ;\
   rm -fr c036_X ;\
   mkdir c036_X ;\
   (cd c036_X ; $(COMPILE) ../c036 >stdout ) 1>2 2>c036_X/stderr ;\
   if test -r c036/stdout;\
     then diff c036/stdout c036_X/stdout;\
     else cat c036_X/stdout;\
   fi;\
   if test -r c036/stderr;\
     then diff c036/stderr c036_X/stderr;\
     else cat c036_X/stderr;\
   fi;\
   rm -f c036_X/a.out

all:: c037_X
new_base:: c037_base
scratch:: ; -rm -fr c037_X
c037:: c037_X
c037_base:: c037_X ; @mv c037_X/stdout c037_X/stderr c037
c037_X:: FRC ;\
-@ echo --- c037 ---  "NEW of opaque OBJECTs with default and non-default slots"  ;\
   rm -fr c037_X ;\
   mkdir c037_X ;\
   (cd c037_X ; $(COMPILE) ../c037 >stdout ) 1>2 2>c037_X/stderr ;\
   if test -r c037/stdout;\
     then diff c037/stdout c037_X/stdout;\
     else cat c037_X/stdout;\
   fi;\
   if test -r c037/stderr;\
     then diff c037/stderr c037_X/stderr;\
     else cat c037_X/stderr;\
   fi;\
   rm -f c037_X/a.out

all:: c038_X
new_base:: c038_base
scratch:: ; -rm -fr c038_X
c038:: c038_X
c038_base:: c038_X ; @mv c038_X/stdout c038_X/stderr c038
c038_X:: FRC ;\
-@ echo --- c038 ---  "open ARRAY indexing"  ;\
   rm -fr c038_X ;\
   mkdir c038_X ;\
   (cd c038_X ; $(COMPILE) ../c038 >stdout ) 1>2 2>c038_X/stderr ;\
   if test -r c038/stdout;\
     then diff c038/stdout c038_X/stdout;\
     else cat c038_X/stdout;\
   fi;\
   if test -r c038/stderr;\
     then diff c038/stderr c038_X/stderr;\
     else cat c038_X/stderr;\
   fi;\
   rm -f c038_X/a.out

all:: c039_X
new_base:: c039_base
scratch:: ; -rm -fr c039_X
c039:: c039_X
c039_base:: c039_X ; @mv c039_X/stdout c039_X/stderr c039
c039_X:: FRC ;\
-@ echo --- c039 ---  "SUBARRAY"  ;\
   rm -fr c039_X ;\
   mkdir c039_X ;\
   (cd c039_X ; $(COMPILE) ../c039 >stdout ) 1>2 2>c039_X/stderr ;\
   if test -r c039/stdout;\
     then diff c039/stdout c039_X/stdout;\
     else cat c039_X/stdout;\
   fi;\
   if test -r c039/stderr;\
     then diff c039/stderr c039_X/stderr;\
     else cat c039_X/stderr;\
   fi;\
   rm -f c039_X/a.out

all:: c040_X
new_base:: c040_base
scratch:: ; -rm -fr c040_X
c040:: c040_X
c040_base:: c040_X ; @mv c040_X/stdout c040_X/stderr c040
c040_X:: FRC ;\
-@ echo --- c040 ---  "large INTEGER constants"  ;\
   rm -fr c040_X ;\
   mkdir c040_X ;\
   (cd c040_X ; $(COMPILE) ../c040 >stdout ) 1>2 2>c040_X/stderr ;\
   if test -r c040/stdout;\
     then diff c040/stdout c040_X/stdout;\
     else cat c040_X/stdout;\
   fi;\
   if test -r c040/stderr;\
     then diff c040/stderr c040_X/stderr;\
     else cat c040_X/stderr;\
   fi;\
   rm -f c040_X/a.out

all:: c041_X
new_base:: c041_base
scratch:: ; -rm -fr c041_X
c041:: c041_X
c041_base:: c041_X ; @mv c041_X/stdout c041_X/stderr c041
c041_X:: FRC ;\
-@ echo --- c041 ---  "FIRST and LAST as constants"  ;\
   rm -fr c041_X ;\
   mkdir c041_X ;\
   (cd c041_X ; $(COMPILE) ../c041 >stdout ) 1>2 2>c041_X/stderr ;\
   if test -r c041/stdout;\
     then diff c041/stdout c041_X/stdout;\
     else cat c041_X/stdout;\
   fi;\
   if test -r c041/stderr;\
     then diff c041/stderr c041_X/stderr;\
     else cat c041_X/stderr;\
   fi;\
   rm -f c041_X/a.out

all:: c042_X
new_base:: c042_base
scratch:: ; -rm -fr c042_X
c042:: c042_X
c042_base:: c042_X ; @mv c042_X/stdout c042_X/stderr c042
c042_X:: FRC ;\
-@ echo --- c042 ---  "SET declarations and constants"  ;\
   rm -fr c042_X ;\
   mkdir c042_X ;\
   (cd c042_X ; $(COMPILE) ../c042 >stdout ) 1>2 2>c042_X/stderr ;\
   if test -r c042/stdout;\
     then diff c042/stdout c042_X/stdout;\
     else cat c042_X/stdout;\
   fi;\
   if test -r c042/stderr;\
     then diff c042/stderr c042_X/stderr;\
     else cat c042_X/stderr;\
   fi;\
   rm -f c042_X/a.out

all:: c043_X
new_base:: c043_base
scratch:: ; -rm -fr c043_X
c043:: c043_X
c043_base:: c043_X ; @mv c043_X/stdout c043_X/stderr c043
c043_X:: FRC ;\
-@ echo --- c043 ---  "RECORD constants"  ;\
   rm -fr c043_X ;\
   mkdir c043_X ;\
   (cd c043_X ; $(COMPILE) ../c043 >stdout ) 1>2 2>c043_X/stderr ;\
   if test -r c043/stdout;\
     then diff c043/stdout c043_X/stdout;\
     else cat c043_X/stdout;\
   fi;\
   if test -r c043/stderr;\
     then diff c043/stderr c043_X/stderr;\
     else cat c043_X/stderr;\
   fi;\
   rm -f c043_X/a.out

all:: c044_X
new_base:: c044_base
scratch:: ; -rm -fr c044_X
c044:: c044_X
c044_base:: c044_X ; @mv c044_X/stdout c044_X/stderr c044
c044_X:: FRC ;\
-@ echo --- c044 ---  "escape character literals"  ;\
   rm -fr c044_X ;\
   mkdir c044_X ;\
   (cd c044_X ; $(COMPILE) ../c044 >stdout ) 1>2 2>c044_X/stderr ;\
   if test -r c044/stdout;\
     then diff c044/stdout c044_X/stdout;\
     else cat c044_X/stdout;\
   fi;\
   if test -r c044/stderr;\
     then diff c044/stderr c044_X/stderr;\
     else cat c044_X/stderr;\
   fi;\
   rm -f c044_X/a.out

all:: c045_X
new_base:: c045_base
scratch:: ; -rm -fr c045_X
c045:: c045_X
c045_base:: c045_X ; @mv c045_X/stdout c045_X/stderr c045
c045_X:: FRC ;\
-@ echo --- c045 ---  "Text.PutStr -  passing a fixed array to an open array formal"  ;\
   rm -fr c045_X ;\
   mkdir c045_X ;\
   (cd c045_X ; $(COMPILE) ../c045 >stdout ) 1>2 2>c045_X/stderr ;\
   if test -r c045/stdout;\
     then diff c045/stdout c045_X/stdout;\
     else cat c045_X/stdout;\
   fi;\
   if test -r c045/stderr;\
     then diff c045/stderr c045_X/stderr;\
     else cat c045_X/stderr;\
   fi;\
   rm -f c045_X/a.out

all:: c046_X
new_base:: c046_base
scratch:: ; -rm -fr c046_X
c046:: c046_X
c046_base:: c046_X ; @mv c046_X/stdout c046_X/stderr c046
c046_X:: FRC ;\
-@ echo --- c046 ---  "declaring an opaque type"  ;\
   rm -fr c046_X ;\
   mkdir c046_X ;\
   (cd c046_X ; $(COMPILE) ../c046 >stdout ) 1>2 2>c046_X/stderr ;\
   if test -r c046/stdout;\
     then diff c046/stdout c046_X/stdout;\
     else cat c046_X/stdout;\
   fi;\
   if test -r c046/stderr;\
     then diff c046/stderr c046_X/stderr;\
     else cat c046_X/stderr;\
   fi;\
   rm -f c046_X/a.out

all:: c047_X
new_base:: c047_base
scratch:: ; -rm -fr c047_X
c047:: c047_X
c047_base:: c047_X ; @mv c047_X/stdout c047_X/stderr c047
c047_X:: FRC ;\
-@ echo --- c047 ---  "RAISE statements"  ;\
   rm -fr c047_X ;\
   mkdir c047_X ;\
   (cd c047_X ; $(COMPILE) ../c047 >stdout ) 1>2 2>c047_X/stderr ;\
   if test -r c047/stdout;\
     then diff c047/stdout c047_X/stdout;\
     else cat c047_X/stdout;\
   fi;\
   if test -r c047/stderr;\
     then diff c047/stderr c047_X/stderr;\
     else cat c047_X/stderr;\
   fi;\
   rm -f c047_X/a.out

all:: c048_X
new_base:: c048_base
scratch:: ; -rm -fr c048_X
c048:: c048_X
c048_base:: c048_X ; @mv c048_X/stdout c048_X/stderr c048
c048_X:: FRC ;\
-@ echo --- c048 ---  "NUMBER"  ;\
   rm -fr c048_X ;\
   mkdir c048_X ;\
   (cd c048_X ; $(COMPILE) ../c048 >stdout ) 1>2 2>c048_X/stderr ;\
   if test -r c048/stdout;\
     then diff c048/stdout c048_X/stdout;\
     else cat c048_X/stdout;\
   fi;\
   if test -r c048/stderr;\
     then diff c048/stderr c048_X/stderr;\
     else cat c048_X/stderr;\
   fi;\
   rm -f c048_X/a.out

all:: c049_X
new_base:: c049_base
scratch:: ; -rm -fr c049_X
c049:: c049_X
c049_base:: c049_X ; @mv c049_X/stdout c049_X/stderr c049
c049_X:: FRC ;\
-@ echo --- c049 ---  "based constants and BITS FOR..."  ;\
   rm -fr c049_X ;\
   mkdir c049_X ;\
   (cd c049_X ; $(COMPILE) ../c049 >stdout ) 1>2 2>c049_X/stderr ;\
   if test -r c049/stdout;\
     then diff c049/stdout c049_X/stdout;\
     else cat c049_X/stdout;\
   fi;\
   if test -r c049/stderr;\
     then diff c049/stderr c049_X/stderr;\
     else cat c049_X/stderr;\
   fi;\
   rm -f c049_X/a.out

all:: c050_X
new_base:: c050_base
scratch:: ; -rm -fr c050_X
c050:: c050_X
c050_base:: c050_X ; @mv c050_X/stdout c050_X/stderr c050
c050_X:: FRC ;\
-@ echo --- c050 ---  "opaque object types"  ;\
   rm -fr c050_X ;\
   mkdir c050_X ;\
   (cd c050_X ; $(COMPILE) ../c050 >stdout ) 1>2 2>c050_X/stderr ;\
   if test -r c050/stdout;\
     then diff c050/stdout c050_X/stdout;\
     else cat c050_X/stdout;\
   fi;\
   if test -r c050/stderr;\
     then diff c050/stderr c050_X/stderr;\
     else cat c050_X/stderr;\
   fi;\
   rm -f c050_X/a.out

all:: c051_X
new_base:: c051_base
scratch:: ; -rm -fr c051_X
c051:: c051_X
c051_base:: c051_X ; @mv c051_X/stdout c051_X/stderr c051
c051_X:: FRC ;\
-@ echo --- c051 ---  "revealing objects"  ;\
   rm -fr c051_X ;\
   mkdir c051_X ;\
   (cd c051_X ; $(COMPILE) ../c051 >stdout ) 1>2 2>c051_X/stderr ;\
   if test -r c051/stdout;\
     then diff c051/stdout c051_X/stdout;\
     else cat c051_X/stdout;\
   fi;\
   if test -r c051/stderr;\
     then diff c051/stderr c051_X/stderr;\
     else cat c051_X/stderr;\
   fi;\
   rm -f c051_X/a.out

all:: c052_X
new_base:: c052_base
scratch:: ; -rm -fr c052_X
c052:: c052_X
c052_base:: c052_X ; @mv c052_X/stdout c052_X/stderr c052
c052_X:: FRC ;\
-@ echo --- c052 ---  "type identification"  ;\
   rm -fr c052_X ;\
   mkdir c052_X ;\
   (cd c052_X ; $(COMPILE) ../c052 >stdout ) 1>2 2>c052_X/stderr ;\
   if test -r c052/stdout;\
     then diff c052/stdout c052_X/stdout;\
     else cat c052_X/stdout;\
   fi;\
   if test -r c052/stderr;\
     then diff c052/stderr c052_X/stderr;\
     else cat c052_X/stderr;\
   fi;\
   rm -f c052_X/a.out

all:: c053_X
new_base:: c053_base
scratch:: ; -rm -fr c053_X
c053:: c053_X
c053_base:: c053_X ; @mv c053_X/stdout c053_X/stderr c053
c053_X:: FRC ;\
-@ echo --- c053 ---  "MAX"  ;\
   rm -fr c053_X ;\
   mkdir c053_X ;\
   (cd c053_X ; $(COMPILE) ../c053 >stdout ) 1>2 2>c053_X/stderr ;\
   if test -r c053/stdout;\
     then diff c053/stdout c053_X/stdout;\
     else cat c053_X/stdout;\
   fi;\
   if test -r c053/stderr;\
     then diff c053/stderr c053_X/stderr;\
     else cat c053_X/stderr;\
   fi;\
   rm -f c053_X/a.out

all:: c054_X
new_base:: c054_base
scratch:: ; -rm -fr c054_X
c054:: c054_X
c054_base:: c054_X ; @mv c054_X/stdout c054_X/stderr c054
c054_X:: FRC ;\
-@ echo --- c054 ---  "coverage of builtinWord"  ;\
   rm -fr c054_X ;\
   mkdir c054_X ;\
   (cd c054_X ; $(COMPILE) ../c054 >stdout ) 1>2 2>c054_X/stderr ;\
   if test -r c054/stdout;\
     then diff c054/stdout c054_X/stdout;\
     else cat c054_X/stdout;\
   fi;\
   if test -r c054/stderr;\
     then diff c054/stderr c054_X/stderr;\
     else cat c054_X/stderr;\
   fi;\
   rm -f c054_X/a.out

all:: c055_X
new_base:: c055_base
scratch:: ; -rm -fr c055_X
c055:: c055_X
c055_base:: c055_X ; @mv c055_X/stdout c055_X/stderr c055
c055_X:: FRC ;\
-@ echo --- c055 ---  "coverage of arithmetic operations and relations"  ;\
   rm -fr c055_X ;\
   mkdir c055_X ;\
   (cd c055_X ; $(COMPILE) ../c055 >stdout ) 1>2 2>c055_X/stderr ;\
   if test -r c055/stdout;\
     then diff c055/stdout c055_X/stdout;\
     else cat c055_X/stdout;\
   fi;\
   if test -r c055/stderr;\
     then diff c055/stderr c055_X/stderr;\
     else cat c055_X/stderr;\
   fi;\
   rm -f c055_X/a.out

all:: c056_X
new_base:: c056_base
scratch:: ; -rm -fr c056_X
c056:: c056_X
c056_base:: c056_X ; @mv c056_X/stdout c056_X/stderr c056
c056_X:: FRC ;\
-@ echo --- c056 ---  "twisted mutually recursive types"  ;\
   rm -fr c056_X ;\
   mkdir c056_X ;\
   (cd c056_X ; $(COMPILE) ../c056 >stdout ) 1>2 2>c056_X/stderr ;\
   if test -r c056/stdout;\
     then diff c056/stdout c056_X/stdout;\
     else cat c056_X/stdout;\
   fi;\
   if test -r c056/stderr;\
     then diff c056/stderr c056_X/stderr;\
     else cat c056_X/stderr;\
   fi;\
   rm -f c056_X/a.out

all:: c057_X
new_base:: c057_base
scratch:: ; -rm -fr c057_X
c057:: c057_X
c057_base:: c057_X ; @mv c057_X/stdout c057_X/stderr c057
c057_X:: FRC ;\
-@ echo --- c057 ---  "CSE on array indexing expressions"  ;\
   rm -fr c057_X ;\
   mkdir c057_X ;\
   (cd c057_X ; $(COMPILE) ../c057 >stdout ) 1>2 2>c057_X/stderr ;\
   if test -r c057/stdout;\
     then diff c057/stdout c057_X/stdout;\
     else cat c057_X/stdout;\
   fi;\
   if test -r c057/stderr;\
     then diff c057/stderr c057_X/stderr;\
     else cat c057_X/stderr;\
   fi;\
   rm -f c057_X/a.out

all:: c058_X
new_base:: c058_base
scratch:: ; -rm -fr c058_X
c058:: c058_X
c058_base:: c058_X ; @mv c058_X/stdout c058_X/stderr c058
c058_X:: FRC ;\
-@ echo --- c058 ---  "open array parameters"  ;\
   rm -fr c058_X ;\
   mkdir c058_X ;\
   (cd c058_X ; $(COMPILE) ../c058 >stdout ) 1>2 2>c058_X/stderr ;\
   if test -r c058/stdout;\
     then diff c058/stdout c058_X/stdout;\
     else cat c058_X/stdout;\
   fi;\
   if test -r c058/stderr;\
     then diff c058/stderr c058_X/stderr;\
     else cat c058_X/stderr;\
   fi;\
   rm -f c058_X/a.out

all:: c059_X
new_base:: c059_base
scratch:: ; -rm -fr c059_X
c059:: c059_X
c059_base:: c059_X ; @mv c059_X/stdout c059_X/stderr c059
c059_X:: FRC ;\
-@ echo --- c059 ---  "recursive types and constant expressions"  ;\
   rm -fr c059_X ;\
   mkdir c059_X ;\
   (cd c059_X ; $(COMPILE) ../c059 >stdout ) 1>2 2>c059_X/stderr ;\
   if test -r c059/stdout;\
     then diff c059/stdout c059_X/stdout;\
     else cat c059_X/stdout;\
   fi;\
   if test -r c059/stderr;\
     then diff c059/stderr c059_X/stderr;\
     else cat c059_X/stderr;\
   fi;\
   rm -f c059_X/a.out

all:: c060_X
new_base:: c060_base
scratch:: ; -rm -fr c060_X
c060:: c060_X
c060_base:: c060_X ; @mv c060_X/stdout c060_X/stderr c060
c060_X:: FRC ;\
-@ echo --- c060 ---  "nested procedures and variables"  ;\
   rm -fr c060_X ;\
   mkdir c060_X ;\
   (cd c060_X ; $(COMPILE) ../c060 >stdout ) 1>2 2>c060_X/stderr ;\
   if test -r c060/stdout;\
     then diff c060/stdout c060_X/stdout;\
     else cat c060_X/stdout;\
   fi;\
   if test -r c060/stderr;\
     then diff c060/stderr c060_X/stderr;\
     else cat c060_X/stderr;\
   fi;\
   rm -f c060_X/a.out

all:: c061_X
new_base:: c061_base
scratch:: ; -rm -fr c061_X
c061:: c061_X
c061_base:: c061_X ; @mv c061_X/stdout c061_X/stderr c061
c061_X:: FRC ;\
-@ echo --- c061 ---  "CASE statements"  ;\
   rm -fr c061_X ;\
   mkdir c061_X ;\
   (cd c061_X ; $(COMPILE) ../c061 >stdout ) 1>2 2>c061_X/stderr ;\
   if test -r c061/stdout;\
     then diff c061/stdout c061_X/stdout;\
     else cat c061_X/stdout;\
   fi;\
   if test -r c061/stderr;\
     then diff c061/stderr c061_X/stderr;\
     else cat c061_X/stderr;\
   fi;\
   rm -f c061_X/a.out

all:: c062_X
new_base:: c062_base
scratch:: ; -rm -fr c062_X
c062:: c062_X
c062_base:: c062_X ; @mv c062_X/stdout c062_X/stderr c062
c062_X:: FRC ;\
-@ echo --- c062 ---  "RCmaps of REF types"  ;\
   rm -fr c062_X ;\
   mkdir c062_X ;\
   (cd c062_X ; $(COMPILE) ../c062 >stdout ) 1>2 2>c062_X/stderr ;\
   if test -r c062/stdout;\
     then diff c062/stdout c062_X/stdout;\
     else cat c062_X/stdout;\
   fi;\
   if test -r c062/stderr;\
     then diff c062/stderr c062_X/stderr;\
     else cat c062_X/stderr;\
   fi;\
   rm -f c062_X/a.out

all:: c063_X
new_base:: c063_base
scratch:: ; -rm -fr c063_X
c063:: c063_X
c063_base:: c063_X ; @mv c063_X/stdout c063_X/stderr c063
c063_X:: FRC ;\
-@ echo --- c063 ---  "NIL is a ROOT"  ;\
   rm -fr c063_X ;\
   mkdir c063_X ;\
   (cd c063_X ; $(COMPILE) ../c063 >stdout ) 1>2 2>c063_X/stderr ;\
   if test -r c063/stdout;\
     then diff c063/stdout c063_X/stdout;\
     else cat c063_X/stdout;\
   fi;\
   if test -r c063/stderr;\
     then diff c063/stderr c063_X/stderr;\
     else cat c063_X/stderr;\
   fi;\
   rm -f c063_X/a.out

all:: c064_X
new_base:: c064_base
scratch:: ; -rm -fr c064_X
c064:: c064_X
c064_base:: c064_X ; @mv c064_X/stdout c064_X/stderr c064
c064_X:: FRC ;\
-@ echo --- c064 ---  "common subexpressions are not always common"  ;\
   rm -fr c064_X ;\
   mkdir c064_X ;\
   (cd c064_X ; $(COMPILE) ../c064 >stdout ) 1>2 2>c064_X/stderr ;\
   if test -r c064/stdout;\
     then diff c064/stdout c064_X/stdout;\
     else cat c064_X/stdout;\
   fi;\
   if test -r c064/stderr;\
     then diff c064/stderr c064_X/stderr;\
     else cat c064_X/stderr;\
   fi;\
   rm -f c064_X/a.out

all:: c065_X
new_base:: c065_base
scratch:: ; -rm -fr c065_X
c065:: c065_X
c065_base:: c065_X ; @mv c065_X/stdout c065_X/stderr c065
c065_X:: FRC ;\
-@ echo --- c065 ---  "ADDRESS arithmetic"  ;\
   rm -fr c065_X ;\
   mkdir c065_X ;\
   (cd c065_X ; $(COMPILE) ../c065 >stdout ) 1>2 2>c065_X/stderr ;\
   if test -r c065/stdout;\
     then diff c065/stdout c065_X/stdout;\
     else cat c065_X/stdout;\
   fi;\
   if test -r c065/stderr;\
     then diff c065/stderr c065_X/stderr;\
     else cat c065_X/stderr;\
   fi;\
   rm -f c065_X/a.out

all:: c066_X
new_base:: c066_base
scratch:: ; -rm -fr c066_X
c066:: c066_X
c066_base:: c066_X ; @mv c066_X/stdout c066_X/stderr c066
c066_X:: FRC ;\
-@ echo --- c066 ---  "Constructor expressions"  ;\
   rm -fr c066_X ;\
   mkdir c066_X ;\
   (cd c066_X ; $(COMPILE) ../c066 >stdout ) 1>2 2>c066_X/stderr ;\
   if test -r c066/stdout;\
     then diff c066/stdout c066_X/stdout;\
     else cat c066_X/stdout;\
   fi;\
   if test -r c066/stderr;\
     then diff c066/stderr c066_X/stderr;\
     else cat c066_X/stderr;\
   fi;\
   rm -f c066_X/a.out

all:: c067_X
new_base:: c067_base
scratch:: ; -rm -fr c067_X
c067:: c067_X
c067_base:: c067_X ; @mv c067_X/stdout c067_X/stderr c067
c067_X:: FRC ;\
-@ echo --- c067 ---  "EXTERNAL vs. non EXTERNAL"  ;\
   rm -fr c067_X ;\
   mkdir c067_X ;\
   (cd c067_X ; $(COMPILE) ../c067 >stdout ) 1>2 2>c067_X/stderr ;\
   if test -r c067/stdout;\
     then diff c067/stdout c067_X/stdout;\
     else cat c067_X/stdout;\
   fi;\
   if test -r c067/stderr;\
     then diff c067/stderr c067_X/stderr;\
     else cat c067_X/stderr;\
   fi;\
   rm -f c067_X/a.out

all:: c068_X
new_base:: c068_base
scratch:: ; -rm -fr c068_X
c068:: c068_X
c068_base:: c068_X ; @mv c068_X/stdout c068_X/stderr c068
c068_X:: FRC ;\
-@ echo --- c068 ---  "does refany have a typecell ?"  ;\
   rm -fr c068_X ;\
   mkdir c068_X ;\
   (cd c068_X ; $(COMPILE) ../c068 >stdout ) 1>2 2>c068_X/stderr ;\
   if test -r c068/stdout;\
     then diff c068/stdout c068_X/stdout;\
     else cat c068_X/stdout;\
   fi;\
   if test -r c068/stderr;\
     then diff c068/stderr c068_X/stderr;\
     else cat c068_X/stderr;\
   fi;\
   rm -f c068_X/a.out

all:: c069_X
new_base:: c069_base
scratch:: ; -rm -fr c069_X
c069:: c069_X
c069_base:: c069_X ; @mv c069_X/stdout c069_X/stderr c069
c069_X:: FRC ;\
-@ echo --- c069 ---  "assignment of open arrays"  ;\
   rm -fr c069_X ;\
   mkdir c069_X ;\
   (cd c069_X ; $(COMPILE) ../c069 >stdout ) 1>2 2>c069_X/stderr ;\
   if test -r c069/stdout;\
     then diff c069/stdout c069_X/stdout;\
     else cat c069_X/stdout;\
   fi;\
   if test -r c069/stderr;\
     then diff c069/stderr c069_X/stderr;\
     else cat c069_X/stderr;\
   fi;\
   rm -f c069_X/a.out

all:: c070_X
new_base:: c070_base
scratch:: ; -rm -fr c070_X
c070:: c070_X
c070_base:: c070_X ; @mv c070_X/stdout c070_X/stderr c070
c070_X:: FRC ;\
-@ echo --- c070 ---  "scopes"  ;\
   rm -fr c070_X ;\
   mkdir c070_X ;\
   (cd c070_X ; $(COMPILE) ../c070 >stdout ) 1>2 2>c070_X/stderr ;\
   if test -r c070/stdout;\
     then diff c070/stdout c070_X/stdout;\
     else cat c070_X/stdout;\
   fi;\
   if test -r c070/stderr;\
     then diff c070/stderr c070_X/stderr;\
     else cat c070_X/stderr;\
   fi;\
   rm -f c070_X/a.out

all:: c071_X
new_base:: c071_base
scratch:: ; -rm -fr c071_X
c071:: c071_X
c071_base:: c071_X ; @mv c071_X/stdout c071_X/stderr c071
c071_X:: FRC ;\
-@ echo --- c071 ---  "procedures that return structures in C"  ;\
   rm -fr c071_X ;\
   mkdir c071_X ;\
   (cd c071_X ; $(COMPILE) ../c071 >stdout ) 1>2 2>c071_X/stderr ;\
   if test -r c071/stdout;\
     then diff c071/stdout c071_X/stdout;\
     else cat c071_X/stdout;\
   fi;\
   if test -r c071/stderr;\
     then diff c071/stderr c071_X/stderr;\
     else cat c071_X/stderr;\
   fi;\
   rm -f c071_X/a.out

all:: c072_X
new_base:: c072_base
scratch:: ; -rm -fr c072_X
c072:: c072_X
c072_base:: c072_X ; @mv c072_X/stdout c072_X/stderr c072
c072_X:: FRC ;\
-@ echo --- c072 ---  "ASSERT"  ;\
   rm -fr c072_X ;\
   mkdir c072_X ;\
   (cd c072_X ; $(COMPILE) ../c072 >stdout ) 1>2 2>c072_X/stderr ;\
   if test -r c072/stdout;\
     then diff c072/stdout c072_X/stdout;\
     else cat c072_X/stdout;\
   fi;\
   if test -r c072/stderr;\
     then diff c072/stderr c072_X/stderr;\
     else cat c072_X/stderr;\
   fi;\
   rm -f c072_X/a.out

all:: c073_X
new_base:: c073_base
scratch:: ; -rm -fr c073_X
c073:: c073_X
c073_base:: c073_X ; @mv c073_X/stdout c073_X/stderr c073
c073_X:: FRC ;\
-@ echo --- c073 ---  "procedure arguments"  ;\
   rm -fr c073_X ;\
   mkdir c073_X ;\
   (cd c073_X ; $(COMPILE) ../c073 >stdout ) 1>2 2>c073_X/stderr ;\
   if test -r c073/stdout;\
     then diff c073/stdout c073_X/stdout;\
     else cat c073_X/stdout;\
   fi;\
   if test -r c073/stderr;\
     then diff c073/stderr c073_X/stderr;\
     else cat c073_X/stderr;\
   fi;\
   rm -f c073_X/a.out

all:: c074_X
new_base:: c074_base
scratch:: ; -rm -fr c074_X
c074:: c074_X
c074_base:: c074_X ; @mv c074_X/stdout c074_X/stderr c074
c074_X:: FRC ;\
-@ echo --- c074 ---  "INC and DEC - range checking"  ;\
   rm -fr c074_X ;\
   mkdir c074_X ;\
   (cd c074_X ; $(COMPILE) ../c074 >stdout ) 1>2 2>c074_X/stderr ;\
   if test -r c074/stdout;\
     then diff c074/stdout c074_X/stdout;\
     else cat c074_X/stdout;\
   fi;\
   if test -r c074/stderr;\
     then diff c074/stderr c074_X/stderr;\
     else cat c074_X/stderr;\
   fi;\
   rm -f c074_X/a.out

all:: c075_X
new_base:: c075_base
scratch:: ; -rm -fr c075_X
c075:: c075_X
c075_base:: c075_X ; @mv c075_X/stdout c075_X/stderr c075
c075_X:: FRC ;\
-@ echo --- c075 ---  "casting open/fixed array to/from open/fixed array"  ;\
   rm -fr c075_X ;\
   mkdir c075_X ;\
   (cd c075_X ; $(COMPILE) ../c075 >stdout ) 1>2 2>c075_X/stderr ;\
   if test -r c075/stdout;\
     then diff c075/stdout c075_X/stdout;\
     else cat c075_X/stdout;\
   fi;\
   if test -r c075/stderr;\
     then diff c075/stderr c075_X/stderr;\
     else cat c075_X/stderr;\
   fi;\
   rm -f c075_X/a.out

all:: c076_X
new_base:: c076_base
scratch:: ; -rm -fr c076_X
c076:: c076_X
c076_base:: c076_X ; @mv c076_X/stdout c076_X/stderr c076
c076_X:: FRC ;\
-@ echo --- c076 ---  "b3tests/b005 - more array problems"  ;\
   rm -fr c076_X ;\
   mkdir c076_X ;\
   (cd c076_X ; $(COMPILE) ../c076 >stdout ) 1>2 2>c076_X/stderr ;\
   if test -r c076/stdout;\
     then diff c076/stdout c076_X/stdout;\
     else cat c076_X/stdout;\
   fi;\
   if test -r c076/stderr;\
     then diff c076/stderr c076_X/stderr;\
     else cat c076_X/stderr;\
   fi;\
   rm -f c076_X/a.out

all:: c077_X
new_base:: c077_base
scratch:: ; -rm -fr c077_X
c077:: c077_X
c077_base:: c077_X ; @mv c077_X/stdout c077_X/stderr c077
c077_X:: FRC ;\
-@ echo --- c077 ---  "global type names"  ;\
   rm -fr c077_X ;\
   mkdir c077_X ;\
   (cd c077_X ; $(COMPILE) ../c077 >stdout ) 1>2 2>c077_X/stderr ;\
   if test -r c077/stdout;\
     then diff c077/stdout c077_X/stdout;\
     else cat c077_X/stdout;\
   fi;\
   if test -r c077/stderr;\
     then diff c077/stderr c077_X/stderr;\
     else cat c077_X/stderr;\
   fi;\
   rm -f c077_X/a.out

all:: c078_X
new_base:: c078_base
scratch:: ; -rm -fr c078_X
c078:: c078_X
c078_base:: c078_X ; @mv c078_X/stdout c078_X/stderr c078
c078_X:: FRC ;\
-@ echo --- c078 ---  "8-bit characters"  ;\
   rm -fr c078_X ;\
   mkdir c078_X ;\
   (cd c078_X ; $(COMPILE) ../c078 >stdout ) 1>2 2>c078_X/stderr ;\
   if test -r c078/stdout;\
     then diff c078/stdout c078_X/stdout;\
     else cat c078_X/stdout;\
   fi;\
   if test -r c078/stderr;\
     then diff c078/stderr c078_X/stderr;\
     else cat c078_X/stderr;\
   fi;\
   rm -f c078_X/a.out

all:: c079_X
new_base:: c079_base
scratch:: ; -rm -fr c079_X
c079:: c079_X
c079_base:: c079_X ; @mv c079_X/stdout c079_X/stderr c079
c079_X:: FRC ;\
-@ echo --- c079 ---  "imported constants and types"  ;\
   rm -fr c079_X ;\
   mkdir c079_X ;\
   (cd c079_X ; $(COMPILE) ../c079 >stdout ) 1>2 2>c079_X/stderr ;\
   if test -r c079/stdout;\
     then diff c079/stdout c079_X/stdout;\
     else cat c079_X/stdout;\
   fi;\
   if test -r c079/stderr;\
     then diff c079/stderr c079_X/stderr;\
     else cat c079_X/stderr;\
   fi;\
   rm -f c079_X/a.out

all:: c080_X
new_base:: c080_base
scratch:: ; -rm -fr c080_X
c080:: c080_X
c080_base:: c080_X ; @mv c080_X/stdout c080_X/stderr c080
c080_X:: FRC ;\
-@ echo --- c080 ---  "REF REF INTEGER"  ;\
   rm -fr c080_X ;\
   mkdir c080_X ;\
   (cd c080_X ; $(COMPILE) ../c080 >stdout ) 1>2 2>c080_X/stderr ;\
   if test -r c080/stdout;\
     then diff c080/stdout c080_X/stdout;\
     else cat c080_X/stdout;\
   fi;\
   if test -r c080/stderr;\
     then diff c080/stderr c080_X/stderr;\
     else cat c080_X/stderr;\
   fi;\
   rm -f c080_X/a.out

all:: c081_X
new_base:: c081_base
scratch:: ; -rm -fr c081_X
c081:: c081_X
c081_base:: c081_X ; @mv c081_X/stdout c081_X/stderr c081
c081_X:: FRC ;\
-@ echo --- c081 ---  "REAL literals as parameters"  ;\
   rm -fr c081_X ;\
   mkdir c081_X ;\
   (cd c081_X ; $(COMPILE) ../c081 >stdout ) 1>2 2>c081_X/stderr ;\
   if test -r c081/stdout;\
     then diff c081/stdout c081_X/stdout;\
     else cat c081_X/stdout;\
   fi;\
   if test -r c081/stderr;\
     then diff c081/stderr c081_X/stderr;\
     else cat c081_X/stderr;\
   fi;\
   rm -f c081_X/a.out

all:: c082_X
new_base:: c082_base
scratch:: ; -rm -fr c082_X
c082:: c082_X
c082_base:: c082_X ; @mv c082_X/stdout c082_X/stderr c082
c082_X:: FRC ;\
-@ echo --- c082 ---  "REAL lvalues vs. rvalues"  ;\
   rm -fr c082_X ;\
   mkdir c082_X ;\
   (cd c082_X ; $(COMPILE) ../c082 >stdout ) 1>2 2>c082_X/stderr ;\
   if test -r c082/stdout;\
     then diff c082/stdout c082_X/stdout;\
     else cat c082_X/stdout;\
   fi;\
   if test -r c082/stderr;\
     then diff c082/stderr c082_X/stderr;\
     else cat c082_X/stderr;\
   fi;\
   rm -f c082_X/a.out

all:: c083_X
new_base:: c083_base
scratch:: ; -rm -fr c083_X
c083:: c083_X
c083_base:: c083_X ; @mv c083_X/stdout c083_X/stderr c083
c083_X:: FRC ;\
-@ echo --- c083 ---  "structured return value from nested procedure"  ;\
   rm -fr c083_X ;\
   mkdir c083_X ;\
   (cd c083_X ; $(COMPILE) ../c083 >stdout ) 1>2 2>c083_X/stderr ;\
   if test -r c083/stdout;\
     then diff c083/stdout c083_X/stdout;\
     else cat c083_X/stdout;\
   fi;\
   if test -r c083/stderr;\
     then diff c083/stderr c083_X/stderr;\
     else cat c083_X/stderr;\
   fi;\
   rm -f c083_X/a.out

all:: c084_X
new_base:: c084_base
scratch:: ; -rm -fr c084_X
c084:: c084_X
c084_base:: c084_X ; @mv c084_X/stdout c084_X/stderr c084
c084_X:: FRC ;\
-@ echo --- c084 ---  "READONLY integer parameters"  ;\
   rm -fr c084_X ;\
   mkdir c084_X ;\
   (cd c084_X ; $(COMPILE) ../c084 >stdout ) 1>2 2>c084_X/stderr ;\
   if test -r c084/stdout;\
     then diff c084/stdout c084_X/stdout;\
     else cat c084_X/stdout;\
   fi;\
   if test -r c084/stderr;\
     then diff c084/stderr c084_X/stderr;\
     else cat c084_X/stderr;\
   fi;\
   rm -f c084_X/a.out

all:: c085_X
new_base:: c085_base
scratch:: ; -rm -fr c085_X
c085:: c085_X
c085_base:: c085_X ; @mv c085_X/stdout c085_X/stderr c085
c085_X:: FRC ;\
-@ echo --- c085 ---  "INC on addresses"  ;\
   rm -fr c085_X ;\
   mkdir c085_X ;\
   (cd c085_X ; $(COMPILE) ../c085 >stdout ) 1>2 2>c085_X/stderr ;\
   if test -r c085/stdout;\
     then diff c085/stdout c085_X/stdout;\
     else cat c085_X/stdout;\
   fi;\
   if test -r c085/stderr;\
     then diff c085/stderr c085_X/stderr;\
     else cat c085_X/stderr;\
   fi;\
   rm -f c085_X/a.out

all:: c086_X
new_base:: c086_base
scratch:: ; -rm -fr c086_X
c086:: c086_X
c086_base:: c086_X ; @mv c086_X/stdout c086_X/stderr c086
c086_X:: FRC ;\
-@ echo --- c086 ---  "LAST on arrays and subranges"  ;\
   rm -fr c086_X ;\
   mkdir c086_X ;\
   (cd c086_X ; $(COMPILE) ../c086 >stdout ) 1>2 2>c086_X/stderr ;\
   if test -r c086/stdout;\
     then diff c086/stdout c086_X/stdout;\
     else cat c086_X/stdout;\
   fi;\
   if test -r c086/stderr;\
     then diff c086/stderr c086_X/stderr;\
     else cat c086_X/stderr;\
   fi;\
   rm -f c086_X/a.out

all:: c087_X
new_base:: c087_base
scratch:: ; -rm -fr c087_X
c087:: c087_X
c087_base:: c087_X ; @mv c087_X/stdout c087_X/stderr c087
c087_X:: FRC ;\
-@ echo --- c087 ---  "chained imports of structured constants"  ;\
   rm -fr c087_X ;\
   mkdir c087_X ;\
   (cd c087_X ; $(COMPILE) ../c087 >stdout ) 1>2 2>c087_X/stderr ;\
   if test -r c087/stdout;\
     then diff c087/stdout c087_X/stdout;\
     else cat c087_X/stdout;\
   fi;\
   if test -r c087/stderr;\
     then diff c087/stderr c087_X/stderr;\
     else cat c087_X/stderr;\
   fi;\
   rm -f c087_X/a.out

all:: c088_X
new_base:: c088_base
scratch:: ; -rm -fr c088_X
c088:: c088_X
c088_base:: c088_X ; @mv c088_X/stdout c088_X/stderr c088
c088_X:: FRC ;\
-@ echo --- c088 ---  "up-level reference of REAL variables"  ;\
   rm -fr c088_X ;\
   mkdir c088_X ;\
   (cd c088_X ; $(COMPILE) ../c088 >stdout ) 1>2 2>c088_X/stderr ;\
   if test -r c088/stdout;\
     then diff c088/stdout c088_X/stdout;\
     else cat c088_X/stdout;\
   fi;\
   if test -r c088/stderr;\
     then diff c088/stderr c088_X/stderr;\
     else cat c088_X/stderr;\
   fi;\
   rm -f c088_X/a.out

all:: c089_X
new_base:: c089_base
scratch:: ; -rm -fr c089_X
c089:: c089_X
c089_base:: c089_X ; @mv c089_X/stdout c089_X/stderr c089
c089_X:: FRC ;\
-@ echo --- c089 ---  "imported equivalent types"  ;\
   rm -fr c089_X ;\
   mkdir c089_X ;\
   (cd c089_X ; $(COMPILE) ../c089 >stdout ) 1>2 2>c089_X/stderr ;\
   if test -r c089/stdout;\
     then diff c089/stdout c089_X/stdout;\
     else cat c089_X/stdout;\
   fi;\
   if test -r c089/stderr;\
     then diff c089/stderr c089_X/stderr;\
     else cat c089_X/stderr;\
   fi;\
   rm -f c089_X/a.out

all:: c090_X
new_base:: c090_base
scratch:: ; -rm -fr c090_X
c090:: c090_X
c090_base:: c090_X ; @mv c090_X/stdout c090_X/stderr c090
c090_X:: FRC ;\
-@ echo --- c090 ---  "arrays of refs"  ;\
   rm -fr c090_X ;\
   mkdir c090_X ;\
   (cd c090_X ; $(COMPILE) ../c090 >stdout ) 1>2 2>c090_X/stderr ;\
   if test -r c090/stdout;\
     then diff c090/stdout c090_X/stdout;\
     else cat c090_X/stdout;\
   fi;\
   if test -r c090/stderr;\
     then diff c090/stderr c090_X/stderr;\
     else cat c090_X/stderr;\
   fi;\
   rm -f c090_X/a.out

all:: c091_X
new_base:: c091_base
scratch:: ; -rm -fr c091_X
c091:: c091_X
c091_base:: c091_X ; @mv c091_X/stdout c091_X/stderr c091
c091_X:: FRC ;\
-@ echo --- c091 ---  "UNUSED and OBSOLETE pragmas"  ;\
   rm -fr c091_X ;\
   mkdir c091_X ;\
   (cd c091_X ; $(COMPILE) ../c091 >stdout ) 1>2 2>c091_X/stderr ;\
   if test -r c091/stdout;\
     then diff c091/stdout c091_X/stdout;\
     else cat c091_X/stdout;\
   fi;\
   if test -r c091/stderr;\
     then diff c091/stderr c091_X/stderr;\
     else cat c091_X/stderr;\
   fi;\
   rm -f c091_X/a.out

all:: c092_X
new_base:: c092_base
scratch:: ; -rm -fr c092_X
c092:: c092_X
c092_base:: c092_X ; @mv c092_X/stdout c092_X/stderr c092
c092_X:: FRC ;\
-@ echo --- c092 ---  "nested procedures"  ;\
   rm -fr c092_X ;\
   mkdir c092_X ;\
   (cd c092_X ; $(COMPILE) ../c092 >stdout ) 1>2 2>c092_X/stderr ;\
   if test -r c092/stdout;\
     then diff c092/stdout c092_X/stdout;\
     else cat c092_X/stdout;\
   fi;\
   if test -r c092/stderr;\
     then diff c092/stderr c092_X/stderr;\
     else cat c092_X/stderr;\
   fi;\
   rm -f c092_X/a.out

all:: c093_X
new_base:: c093_base
scratch:: ; -rm -fr c093_X
c093:: c093_X
c093_base:: c093_X ; @mv c093_X/stdout c093_X/stderr c093
c093_X:: FRC ;\
-@ echo --- c093 ---  "TYPECASE with type expressions"  ;\
   rm -fr c093_X ;\
   mkdir c093_X ;\
   (cd c093_X ; $(COMPILE) ../c093 >stdout ) 1>2 2>c093_X/stderr ;\
   if test -r c093/stdout;\
     then diff c093/stdout c093_X/stdout;\
     else cat c093_X/stdout;\
   fi;\
   if test -r c093/stderr;\
     then diff c093/stderr c093_X/stderr;\
     else cat c093_X/stderr;\
   fi;\
   rm -f c093_X/a.out

all:: c094_X
new_base:: c094_base
scratch:: ; -rm -fr c094_X
c094:: c094_X
c094_base:: c094_X ; @mv c094_X/stdout c094_X/stderr c094
c094_X:: FRC ;\
-@ echo --- c094 ---  "BITS 1 FOR [0..1]"  ;\
   rm -fr c094_X ;\
   mkdir c094_X ;\
   (cd c094_X ; $(COMPILE) ../c094 >stdout ) 1>2 2>c094_X/stderr ;\
   if test -r c094/stdout;\
     then diff c094/stdout c094_X/stdout;\
     else cat c094_X/stdout;\
   fi;\
   if test -r c094/stderr;\
     then diff c094/stderr c094_X/stderr;\
     else cat c094_X/stderr;\
   fi;\
   rm -f c094_X/a.out

all:: c095_X
new_base:: c095_base
scratch:: ; -rm -fr c095_X
c095:: c095_X
c095_base:: c095_X ; @mv c095_X/stdout c095_X/stderr c095
c095_X:: FRC ;\
-@ echo --- c095 ---  "BITS 8 FOR [0..255]"  ;\
   rm -fr c095_X ;\
   mkdir c095_X ;\
   (cd c095_X ; $(COMPILE) ../c095 >stdout ) 1>2 2>c095_X/stderr ;\
   if test -r c095/stdout;\
     then diff c095/stdout c095_X/stdout;\
     else cat c095_X/stdout;\
   fi;\
   if test -r c095/stderr;\
     then diff c095/stderr c095_X/stderr;\
     else cat c095_X/stderr;\
   fi;\
   rm -f c095_X/a.out

all:: c096_X
new_base:: c096_base
scratch:: ; -rm -fr c096_X
c096:: c096_X
c096_base:: c096_X ; @mv c096_X/stdout c096_X/stderr c096
c096_X:: FRC ;\
-@ echo --- c096 ---  "record constructor in WITH statement"  ;\
   rm -fr c096_X ;\
   mkdir c096_X ;\
   (cd c096_X ; $(COMPILE) ../c096 >stdout ) 1>2 2>c096_X/stderr ;\
   if test -r c096/stdout;\
     then diff c096/stdout c096_X/stdout;\
     else cat c096_X/stdout;\
   fi;\
   if test -r c096/stderr;\
     then diff c096/stderr c096_X/stderr;\
     else cat c096_X/stderr;\
   fi;\
   rm -f c096_X/a.out

all:: c097_X
new_base:: c097_base
scratch:: ; -rm -fr c097_X
c097:: c097_X
c097_base:: c097_X ; @mv c097_X/stdout c097_X/stderr c097
c097_X:: FRC ;\
-@ echo --- c097 ---  "recursive types"  ;\
   rm -fr c097_X ;\
   mkdir c097_X ;\
   (cd c097_X ; $(COMPILE) ../c097 >stdout ) 1>2 2>c097_X/stderr ;\
   if test -r c097/stdout;\
     then diff c097/stdout c097_X/stdout;\
     else cat c097_X/stdout;\
   fi;\
   if test -r c097/stderr;\
     then diff c097/stderr c097_X/stderr;\
     else cat c097_X/stderr;\
   fi;\
   rm -f c097_X/a.out

all:: c098_X
new_base:: c098_base
scratch:: ; -rm -fr c098_X
c098:: c098_X
c098_base:: c098_X ; @mv c098_X/stdout c098_X/stderr c098
c098_X:: FRC ;\
-@ echo --- c098 ---  "record constructor with packed fields"  ;\
   rm -fr c098_X ;\
   mkdir c098_X ;\
   (cd c098_X ; $(COMPILE) ../c098 >stdout ) 1>2 2>c098_X/stderr ;\
   if test -r c098/stdout;\
     then diff c098/stdout c098_X/stdout;\
     else cat c098_X/stdout;\
   fi;\
   if test -r c098/stderr;\
     then diff c098/stderr c098_X/stderr;\
     else cat c098_X/stderr;\
   fi;\
   rm -f c098_X/a.out

all:: c099_X
new_base:: c099_base
scratch:: ; -rm -fr c099_X
c099:: c099_X
c099_base:: c099_X ; @mv c099_X/stdout c099_X/stderr c099
c099_X:: FRC ;\
-@ echo --- c099 ---  "local and imported equivalent types"  ;\
   rm -fr c099_X ;\
   mkdir c099_X ;\
   (cd c099_X ; $(COMPILE) ../c099 >stdout ) 1>2 2>c099_X/stderr ;\
   if test -r c099/stdout;\
     then diff c099/stdout c099_X/stdout;\
     else cat c099_X/stdout;\
   fi;\
   if test -r c099/stderr;\
     then diff c099/stderr c099_X/stderr;\
     else cat c099_X/stderr;\
   fi;\
   rm -f c099_X/a.out

all:: c100_X
new_base:: c100_base
scratch:: ; -rm -fr c100_X
c100:: c100_X
c100_base:: c100_X ; @mv c100_X/stdout c100_X/stderr c100
c100_X:: FRC ;\
-@ echo --- c100 ---  "nested procedures and procedure parameters"  ;\
   rm -fr c100_X ;\
   mkdir c100_X ;\
   (cd c100_X ; $(COMPILE) ../c100 >stdout ) 1>2 2>c100_X/stderr ;\
   if test -r c100/stdout;\
     then diff c100/stdout c100_X/stdout;\
     else cat c100_X/stdout;\
   fi;\
   if test -r c100/stderr;\
     then diff c100/stderr c100_X/stderr;\
     else cat c100_X/stderr;\
   fi;\
   rm -f c100_X/a.out

all:: c101_X
new_base:: c101_base
scratch:: ; -rm -fr c101_X
c101:: c101_X
c101_base:: c101_X ; @mv c101_X/stdout c101_X/stderr c101
c101_X:: FRC ;\
-@ echo --- c101 ---  "multiple record constructors in one WITH statement"  ;\
   rm -fr c101_X ;\
   mkdir c101_X ;\
   (cd c101_X ; $(COMPILE) ../c101 >stdout ) 1>2 2>c101_X/stderr ;\
   if test -r c101/stdout;\
     then diff c101/stdout c101_X/stdout;\
     else cat c101_X/stdout;\
   fi;\
   if test -r c101/stderr;\
     then diff c101/stderr c101_X/stderr;\
     else cat c101_X/stderr;\
   fi;\
   rm -f c101_X/a.out

all:: c102_X
new_base:: c102_base
scratch:: ; -rm -fr c102_X
c102:: c102_X
c102_base:: c102_X ; @mv c102_X/stdout c102_X/stderr c102
c102_X:: FRC ;\
-@ echo --- c102 ---  "array constructor"  ;\
   rm -fr c102_X ;\
   mkdir c102_X ;\
   (cd c102_X ; $(COMPILE) ../c102 >stdout ) 1>2 2>c102_X/stderr ;\
   if test -r c102/stdout;\
     then diff c102/stdout c102_X/stdout;\
     else cat c102_X/stdout;\
   fi;\
   if test -r c102/stderr;\
     then diff c102/stderr c102_X/stderr;\
     else cat c102_X/stderr;\
   fi;\
   rm -f c102_X/a.out

all:: c103_X
new_base:: c103_base
scratch:: ; -rm -fr c103_X
c103:: c103_X
c103_base:: c103_X ; @mv c103_X/stdout c103_X/stderr c103
c103_X:: FRC ;\
-@ echo --- c103 ---  "packed vs. non-packed subranges"  ;\
   rm -fr c103_X ;\
   mkdir c103_X ;\
   (cd c103_X ; $(COMPILE) ../c103 >stdout ) 1>2 2>c103_X/stderr ;\
   if test -r c103/stdout;\
     then diff c103/stdout c103_X/stdout;\
     else cat c103_X/stdout;\
   fi;\
   if test -r c103/stderr;\
     then diff c103/stderr c103_X/stderr;\
     else cat c103_X/stderr;\
   fi;\
   rm -f c103_X/a.out

all:: c104_X
new_base:: c104_base
scratch:: ; -rm -fr c104_X
c104:: c104_X
c104_base:: c104_X ; @mv c104_X/stdout c104_X/stderr c104
c104_X:: FRC ;\
-@ echo --- c104 ---  "import and export of same interface"  ;\
   rm -fr c104_X ;\
   mkdir c104_X ;\
   (cd c104_X ; $(COMPILE) ../c104 >stdout ) 1>2 2>c104_X/stderr ;\
   if test -r c104/stdout;\
     then diff c104/stdout c104_X/stdout;\
     else cat c104_X/stdout;\
   fi;\
   if test -r c104/stderr;\
     then diff c104/stderr c104_X/stderr;\
     else cat c104_X/stderr;\
   fi;\
   rm -f c104_X/a.out

all:: c105_X
new_base:: c105_base
scratch:: ; -rm -fr c105_X
c105:: c105_X
c105_base:: c105_X ; @mv c105_X/stdout c105_X/stderr c105
c105_X:: FRC ;\
-@ echo --- c105 ---  "packed record"  ;\
   rm -fr c105_X ;\
   mkdir c105_X ;\
   (cd c105_X ; $(COMPILE) ../c105 >stdout ) 1>2 2>c105_X/stderr ;\
   if test -r c105/stdout;\
     then diff c105/stdout c105_X/stdout;\
     else cat c105_X/stdout;\
   fi;\
   if test -r c105/stderr;\
     then diff c105/stderr c105_X/stderr;\
     else cat c105_X/stderr;\
   fi;\
   rm -f c105_X/a.out

all:: c106_X
new_base:: c106_base
scratch:: ; -rm -fr c106_X
c106:: c106_X
c106_base:: c106_X ; @mv c106_X/stdout c106_X/stderr c106
c106_X:: FRC ;\
-@ echo --- c106 ---  "variable initialization in interface"  ;\
   rm -fr c106_X ;\
   mkdir c106_X ;\
   (cd c106_X ; $(COMPILE) ../c106 >stdout ) 1>2 2>c106_X/stderr ;\
   if test -r c106/stdout;\
     then diff c106/stdout c106_X/stdout;\
     else cat c106_X/stdout;\
   fi;\
   if test -r c106/stderr;\
     then diff c106/stderr c106_X/stderr;\
     else cat c106_X/stderr;\
   fi;\
   rm -f c106_X/a.out

all:: c107_X
new_base:: c107_base
scratch:: ; -rm -fr c107_X
c107:: c107_X
c107_base:: c107_X ; @mv c107_X/stdout c107_X/stderr c107
c107_X:: FRC ;\
-@ echo --- c107 ---  "exported exception"  ;\
   rm -fr c107_X ;\
   mkdir c107_X ;\
   (cd c107_X ; $(COMPILE) ../c107 >stdout ) 1>2 2>c107_X/stderr ;\
   if test -r c107/stdout;\
     then diff c107/stdout c107_X/stdout;\
     else cat c107_X/stdout;\
   fi;\
   if test -r c107/stderr;\
     then diff c107/stderr c107_X/stderr;\
     else cat c107_X/stderr;\
   fi;\
   rm -f c107_X/a.out

all:: c108_X
new_base:: c108_base
scratch:: ; -rm -fr c108_X
c108:: c108_X
c108_base:: c108_X ; @mv c108_X/stdout c108_X/stderr c108
c108_X:: FRC ;\
-@ echo --- c108 ---  "ObjectType.Method as constant"  ;\
   rm -fr c108_X ;\
   mkdir c108_X ;\
   (cd c108_X ; $(COMPILE) ../c108 >stdout ) 1>2 2>c108_X/stderr ;\
   if test -r c108/stdout;\
     then diff c108/stdout c108_X/stdout;\
     else cat c108_X/stdout;\
   fi;\
   if test -r c108/stderr;\
     then diff c108/stderr c108_X/stderr;\
     else cat c108_X/stderr;\
   fi;\
   rm -f c108_X/a.out

all:: c109_X
new_base:: c109_base
scratch:: ; -rm -fr c109_X
c109:: c109_X
c109_base:: c109_X ; @mv c109_X/stdout c109_X/stderr c109
c109_X:: FRC ;\
-@ echo --- c109 ---  "mixed LOOPHOLE and SUBARRAY"  ;\
   rm -fr c109_X ;\
   mkdir c109_X ;\
   (cd c109_X ; $(COMPILE) ../c109 >stdout ) 1>2 2>c109_X/stderr ;\
   if test -r c109/stdout;\
     then diff c109/stdout c109_X/stdout;\
     else cat c109_X/stdout;\
   fi;\
   if test -r c109/stderr;\
     then diff c109/stderr c109_X/stderr;\
     else cat c109_X/stderr;\
   fi;\
   rm -f c109_X/a.out

all:: c110_X
new_base:: c110_base
scratch:: ; -rm -fr c110_X
c110:: c110_X
c110_base:: c110_X ; @mv c110_X/stdout c110_X/stderr c110
c110_X:: FRC ;\
-@ echo --- c110 ---  "ObjectType.Method does not work"  ;\
   rm -fr c110_X ;\
   mkdir c110_X ;\
   (cd c110_X ; $(COMPILE) ../c110 >stdout ) 1>2 2>c110_X/stderr ;\
   if test -r c110/stdout;\
     then diff c110/stdout c110_X/stdout;\
     else cat c110_X/stdout;\
   fi;\
   if test -r c110/stderr;\
     then diff c110/stderr c110_X/stderr;\
     else cat c110_X/stderr;\
   fi;\
   rm -f c110_X/a.out

all:: c111_X
new_base:: c111_base
scratch:: ; -rm -fr c111_X
c111:: c111_X
c111_base:: c111_X ; @mv c111_X/stdout c111_X/stderr c111
c111_X:: FRC ;\
-@ echo --- c111 ---  "external variables should not be initialized"  ;\
   rm -fr c111_X ;\
   mkdir c111_X ;\
   (cd c111_X ; $(COMPILE) ../c111 >stdout ) 1>2 2>c111_X/stderr ;\
   if test -r c111/stdout;\
     then diff c111/stdout c111_X/stdout;\
     else cat c111_X/stdout;\
   fi;\
   if test -r c111/stderr;\
     then diff c111/stderr c111_X/stderr;\
     else cat c111_X/stderr;\
   fi;\
   rm -f c111_X/a.out

all:: c112_X
new_base:: c112_base
scratch:: ; -rm -fr c112_X
c112:: c112_X
c112_base:: c112_X ; @mv c112_X/stdout c112_X/stderr c112
c112_X:: FRC ;\
-@ echo --- c112 ---  "assignable types"  ;\
   rm -fr c112_X ;\
   mkdir c112_X ;\
   (cd c112_X ; $(COMPILE) ../c112 >stdout ) 1>2 2>c112_X/stderr ;\
   if test -r c112/stdout;\
     then diff c112/stdout c112_X/stdout;\
     else cat c112_X/stdout;\
   fi;\
   if test -r c112/stderr;\
     then diff c112/stderr c112_X/stderr;\
     else cat c112_X/stderr;\
   fi;\
   rm -f c112_X/a.out

all:: c113_X
new_base:: c113_base
scratch:: ; -rm -fr c113_X
c113:: c113_X
c113_base:: c113_X ; @mv c113_X/stdout c113_X/stderr c113
c113_X:: FRC ;\
-@ echo --- c113 ---  "size of local copies of value formal arrays"  ;\
   rm -fr c113_X ;\
   mkdir c113_X ;\
   (cd c113_X ; $(COMPILE) ../c113 >stdout ) 1>2 2>c113_X/stderr ;\
   if test -r c113/stdout;\
     then diff c113/stdout c113_X/stdout;\
     else cat c113_X/stdout;\
   fi;\
   if test -r c113/stderr;\
     then diff c113/stderr c113_X/stderr;\
     else cat c113_X/stderr;\
   fi;\
   rm -f c113_X/a.out

all:: c114_X
new_base:: c114_base
scratch:: ; -rm -fr c114_X
c114:: c114_X
c114_base:: c114_X ; @mv c114_X/stdout c114_X/stderr c114
c114_X:: FRC ;\
-@ echo --- c114 ---  "initialization of UNTRACED REF variables"  ;\
   rm -fr c114_X ;\
   mkdir c114_X ;\
   (cd c114_X ; $(COMPILE) ../c114 >stdout ) 1>2 2>c114_X/stderr ;\
   if test -r c114/stdout;\
     then diff c114/stdout c114_X/stdout;\
     else cat c114_X/stdout;\
   fi;\
   if test -r c114/stderr;\
     then diff c114/stderr c114_X/stderr;\
     else cat c114_X/stderr;\
   fi;\
   rm -f c114_X/a.out

all:: c115_X
new_base:: c115_base
scratch:: ; -rm -fr c115_X
c115:: c115_X
c115_base:: c115_X ; @mv c115_X/stdout c115_X/stderr c115
c115_X:: FRC ;\
-@ echo --- c115 ---  ""line 15: illegal operand for MOD" ?"  ;\
   rm -fr c115_X ;\
   mkdir c115_X ;\
   (cd c115_X ; $(COMPILE) ../c115 >stdout ) 1>2 2>c115_X/stderr ;\
   if test -r c115/stdout;\
     then diff c115/stdout c115_X/stdout;\
     else cat c115_X/stdout;\
   fi;\
   if test -r c115/stderr;\
     then diff c115/stderr c115_X/stderr;\
     else cat c115_X/stderr;\
   fi;\
   rm -f c115_X/a.out

all:: c116_X
new_base:: c116_base
scratch:: ; -rm -fr c116_X
c116:: c116_X
c116_base:: c116_X ; @mv c116_X/stdout c116_X/stderr c116
c116_X:: FRC ;\
-@ echo --- c116 ---  "subrange of enumerated type used as array index =b1tests/b003"  ;\
   rm -fr c116_X ;\
   mkdir c116_X ;\
   (cd c116_X ; $(COMPILE) ../c116 >stdout ) 1>2 2>c116_X/stderr ;\
   if test -r c116/stdout;\
     then diff c116/stdout c116_X/stdout;\
     else cat c116_X/stdout;\
   fi;\
   if test -r c116/stderr;\
     then diff c116/stderr c116_X/stderr;\
     else cat c116_X/stderr;\
   fi;\
   rm -f c116_X/a.out

all:: c117_X
new_base:: c117_base
scratch:: ; -rm -fr c117_X
c117:: c117_X
c117_base:: c117_X ; @mv c117_X/stdout c117_X/stderr c117
c117_X:: FRC ;\
-@ echo --- c117 ---  "b1tests/b001 - array constructors"  ;\
   rm -fr c117_X ;\
   mkdir c117_X ;\
   (cd c117_X ; $(COMPILE) ../c117 >stdout ) 1>2 2>c117_X/stderr ;\
   if test -r c117/stdout;\
     then diff c117/stdout c117_X/stdout;\
     else cat c117_X/stdout;\
   fi;\
   if test -r c117/stderr;\
     then diff c117/stderr c117_X/stderr;\
     else cat c117_X/stderr;\
   fi;\
   rm -f c117_X/a.out

all:: c118_X
new_base:: c118_base
scratch:: ; -rm -fr c118_X
c118:: c118_X
c118_base:: c118_X ; @mv c118_X/stdout c118_X/stderr c118
c118_X:: FRC ;\
-@ echo --- c118 ---  "b1tests/b002 - BYTESIZE illegal in CASE ?"  ;\
   rm -fr c118_X ;\
   mkdir c118_X ;\
   (cd c118_X ; $(COMPILE) ../c118 >stdout ) 1>2 2>c118_X/stderr ;\
   if test -r c118/stdout;\
     then diff c118/stdout c118_X/stdout;\
     else cat c118_X/stdout;\
   fi;\
   if test -r c118/stderr;\
     then diff c118/stderr c118_X/stderr;\
     else cat c118_X/stderr;\
   fi;\
   rm -f c118_X/a.out

all:: c119_X
new_base:: c119_base
scratch:: ; -rm -fr c119_X
c119:: c119_X
c119_base:: c119_X ; @mv c119_X/stdout c119_X/stderr c119
c119_X:: FRC ;\
-@ echo --- c119 ---  "b1tests/b004 - open array actual / VAR fixed array formal"  ;\
   rm -fr c119_X ;\
   mkdir c119_X ;\
   (cd c119_X ; $(COMPILE) ../c119 >stdout ) 1>2 2>c119_X/stderr ;\
   if test -r c119/stdout;\
     then diff c119/stdout c119_X/stdout;\
     else cat c119_X/stdout;\
   fi;\
   if test -r c119/stderr;\
     then diff c119/stderr c119_X/stderr;\
     else cat c119_X/stderr;\
   fi;\
   rm -f c119_X/a.out

all:: c120_X
new_base:: c120_base
scratch:: ; -rm -fr c120_X
c120:: c120_X
c120_base:: c120_X ; @mv c120_X/stdout c120_X/stderr c120
c120_X:: FRC ;\
-@ echo --- c120 ---  "b2tests/b001 - empty records cause improper C type"  ;\
   rm -fr c120_X ;\
   mkdir c120_X ;\
   (cd c120_X ; $(COMPILE) ../c120 >stdout ) 1>2 2>c120_X/stderr ;\
   if test -r c120/stdout;\
     then diff c120/stdout c120_X/stdout;\
     else cat c120_X/stdout;\
   fi;\
   if test -r c120/stderr;\
     then diff c120/stderr c120_X/stderr;\
     else cat c120_X/stderr;\
   fi;\
   rm -f c120_X/a.out

all:: c121_X
new_base:: c121_base
scratch:: ; -rm -fr c121_X
c121:: c121_X
c121_base:: c121_X ; @mv c121_X/stdout c121_X/stderr c121
c121_X:: FRC ;\
-@ echo --- c121 ---  "b1tests/b008 - multiple timestamps for a single type"  ;\
   rm -fr c121_X ;\
   mkdir c121_X ;\
   (cd c121_X ; $(COMPILE) ../c121 >stdout ) 1>2 2>c121_X/stderr ;\
   if test -r c121/stdout;\
     then diff c121/stdout c121_X/stdout;\
     else cat c121_X/stdout;\
   fi;\
   if test -r c121/stderr;\
     then diff c121/stderr c121_X/stderr;\
     else cat c121_X/stderr;\
   fi;\
   rm -f c121_X/a.out

all:: c122_X
new_base:: c122_base
scratch:: ; -rm -fr c122_X
c122:: c122_X
c122_base:: c122_X ; @mv c122_X/stdout c122_X/stderr c122
c122_X:: FRC ;\
-@ echo --- c122 ---  "the compiler dumps core !"  ;\
   rm -fr c122_X ;\
   mkdir c122_X ;\
   (cd c122_X ; $(COMPILE) ../c122 >stdout ) 1>2 2>c122_X/stderr ;\
   if test -r c122/stdout;\
     then diff c122/stdout c122_X/stdout;\
     else cat c122_X/stdout;\
   fi;\
   if test -r c122/stderr;\
     then diff c122/stderr c122_X/stderr;\
     else cat c122_X/stderr;\
   fi;\
   rm -f c122_X/a.out

all:: c123_X
new_base:: c123_base
scratch:: ; -rm -fr c123_X
c123:: c123_X
c123_base:: c123_X ; @mv c123_X/stdout c123_X/stderr c123
c123_X:: FRC ;\
-@ echo --- c123 ---  "implicit import of large constants"  ;\
   rm -fr c123_X ;\
   mkdir c123_X ;\
   (cd c123_X ; $(COMPILE) ../c123 >stdout ) 1>2 2>c123_X/stderr ;\
   if test -r c123/stdout;\
     then diff c123/stdout c123_X/stdout;\
     else cat c123_X/stdout;\
   fi;\
   if test -r c123/stderr;\
     then diff c123/stderr c123_X/stderr;\
     else cat c123_X/stderr;\
   fi;\
   rm -f c123_X/a.out

all:: c124_X
new_base:: c124_base
scratch:: ; -rm -fr c124_X
c124:: c124_X
c124_base:: c124_X ; @mv c124_X/stdout c124_X/stderr c124
c124_X:: FRC ;\
-@ echo --- c124 ---  "recursion on Module names is allowed"  ;\
   rm -fr c124_X ;\
   mkdir c124_X ;\
   (cd c124_X ; $(COMPILE) ../c124 >stdout ) 1>2 2>c124_X/stderr ;\
   if test -r c124/stdout;\
     then diff c124/stdout c124_X/stdout;\
     else cat c124_X/stdout;\
   fi;\
   if test -r c124/stderr;\
     then diff c124/stderr c124_X/stderr;\
     else cat c124_X/stderr;\
   fi;\
   rm -f c124_X/a.out

all:: c125_X
new_base:: c125_base
scratch:: ; -rm -fr c125_X
c125:: c125_X
c125_base:: c125_X ; @mv c125_X/stdout c125_X/stderr c125
c125_X:: FRC ;\
-@ echo --- c125 ---  "LAST of subrange assignment in record constructor"  ;\
   rm -fr c125_X ;\
   mkdir c125_X ;\
   (cd c125_X ; $(COMPILE) ../c125 >stdout ) 1>2 2>c125_X/stderr ;\
   if test -r c125/stdout;\
     then diff c125/stdout c125_X/stdout;\
     else cat c125_X/stdout;\
   fi;\
   if test -r c125/stderr;\
     then diff c125/stderr c125_X/stderr;\
     else cat c125_X/stderr;\
   fi;\
   rm -f c125_X/a.out

all:: c126_X
new_base:: c126_base
scratch:: ; -rm -fr c126_X
c126:: c126_X
c126_base:: c126_X ; @mv c126_X/stdout c126_X/stderr c126
c126_X:: FRC ;\
-@ echo --- c126 ---  "assignability of recursive types"  ;\
   rm -fr c126_X ;\
   mkdir c126_X ;\
   (cd c126_X ; $(COMPILE) ../c126 >stdout ) 1>2 2>c126_X/stderr ;\
   if test -r c126/stdout;\
     then diff c126/stdout c126_X/stdout;\
     else cat c126_X/stdout;\
   fi;\
   if test -r c126/stderr;\
     then diff c126/stderr c126_X/stderr;\
     else cat c126_X/stderr;\
   fi;\
   rm -f c126_X/a.out

all:: c127_X
new_base:: c127_base
scratch:: ; -rm -fr c127_X
c127:: c127_X
c127_base:: c127_X ; @mv c127_X/stdout c127_X/stderr c127
c127_X:: FRC ;\
-@ echo --- c127 ---  "nasty scoping and lazy typechecking interactions"  ;\
   rm -fr c127_X ;\
   mkdir c127_X ;\
   (cd c127_X ; $(COMPILE) ../c127 >stdout ) 1>2 2>c127_X/stderr ;\
   if test -r c127/stdout;\
     then diff c127/stdout c127_X/stdout;\
     else cat c127_X/stdout;\
   fi;\
   if test -r c127/stderr;\
     then diff c127/stderr c127_X/stderr;\
     else cat c127_X/stderr;\
   fi;\
   rm -f c127_X/a.out

all:: c128_X
new_base:: c128_base
scratch:: ; -rm -fr c128_X
c128:: c128_X
c128_base:: c128_X ; @mv c128_X/stdout c128_X/stderr c128
c128_X:: FRC ;\
-@ echo --- c128 ---  "nested constructors with procedure values"  ;\
   rm -fr c128_X ;\
   mkdir c128_X ;\
   (cd c128_X ; $(COMPILE) ../c128 >stdout ) 1>2 2>c128_X/stderr ;\
   if test -r c128/stdout;\
     then diff c128/stdout c128_X/stdout;\
     else cat c128_X/stdout;\
   fi;\
   if test -r c128/stderr;\
     then diff c128/stderr c128_X/stderr;\
     else cat c128_X/stderr;\
   fi;\
   rm -f c128_X/a.out

all:: c129_X
new_base:: c129_base
scratch:: ; -rm -fr c129_X
c129:: c129_X
c129_base:: c129_X ; @mv c129_X/stdout c129_X/stderr c129
c129_X:: FRC ;\
-@ echo --- c129 ---  "READONLY subranges of integer"  ;\
   rm -fr c129_X ;\
   mkdir c129_X ;\
   (cd c129_X ; $(COMPILE) ../c129 >stdout ) 1>2 2>c129_X/stderr ;\
   if test -r c129/stdout;\
     then diff c129/stdout c129_X/stdout;\
     else cat c129_X/stdout;\
   fi;\
   if test -r c129/stderr;\
     then diff c129/stderr c129_X/stderr;\
     else cat c129_X/stderr;\
   fi;\
   rm -f c129_X/a.out

all:: c130_X
new_base:: c130_base
scratch:: ; -rm -fr c130_X
c130:: c130_X
c130_base:: c130_X ; @mv c130_X/stdout c130_X/stderr c130
c130_X:: FRC ;\
-@ echo --- c130 ---  "object writers"  ;\
   rm -fr c130_X ;\
   mkdir c130_X ;\
   (cd c130_X ; $(COMPILE) ../c130 >stdout ) 1>2 2>c130_X/stderr ;\
   if test -r c130/stdout;\
     then diff c130/stdout c130_X/stdout;\
     else cat c130_X/stdout;\
   fi;\
   if test -r c130/stderr;\
     then diff c130/stderr c130_X/stderr;\
     else cat c130_X/stderr;\
   fi;\
   rm -f c130_X/a.out

all:: c131_X
new_base:: c131_base
scratch:: ; -rm -fr c131_X
c131:: c131_X
c131_base:: c131_X ; @mv c131_X/stdout c131_X/stderr c131
c131_X:: FRC ;\
-@ echo --- c131 ---  "nested open array constructors"  ;\
   rm -fr c131_X ;\
   mkdir c131_X ;\
   (cd c131_X ; $(COMPILE) ../c131 >stdout ) 1>2 2>c131_X/stderr ;\
   if test -r c131/stdout;\
     then diff c131/stdout c131_X/stdout;\
     else cat c131_X/stdout;\
   fi;\
   if test -r c131/stderr;\
     then diff c131/stderr c131_X/stderr;\
     else cat c131_X/stderr;\
   fi;\
   rm -f c131_X/a.out

all:: c132_X
new_base:: c132_base
scratch:: ; -rm -fr c132_X
c132:: c132_X
c132_base:: c132_X ; @mv c132_X/stdout c132_X/stderr c132
c132_X:: FRC ;\
-@ echo --- c132 ---  "generic list"  ;\
   rm -fr c132_X ;\
   mkdir c132_X ;\
   (cd c132_X ; $(COMPILE) ../c132 >stdout ) 1>2 2>c132_X/stderr ;\
   if test -r c132/stdout;\
     then diff c132/stdout c132_X/stdout;\
     else cat c132_X/stdout;\
   fi;\
   if test -r c132/stderr;\
     then diff c132/stderr c132_X/stderr;\
     else cat c132_X/stderr;\
   fi;\
   rm -f c132_X/a.out

all:: c133_X
new_base:: c133_base
scratch:: ; -rm -fr c133_X
c133:: c133_X
c133_base:: c133_X ; @mv c133_X/stdout c133_X/stderr c133
c133_X:: FRC ;\
-@ echo --- c133 ---  "procedure and method constants"  ;\
   rm -fr c133_X ;\
   mkdir c133_X ;\
   (cd c133_X ; $(COMPILE) ../c133 >stdout ) 1>2 2>c133_X/stderr ;\
   if test -r c133/stdout;\
     then diff c133/stdout c133_X/stdout;\
     else cat c133_X/stdout;\
   fi;\
   if test -r c133/stderr;\
     then diff c133/stderr c133_X/stderr;\
     else cat c133_X/stderr;\
   fi;\
   rm -f c133_X/a.out

all:: c134_X
new_base:: c134_base
scratch:: ; -rm -fr c134_X
c134:: c134_X
c134_base:: c134_X ; @mv c134_X/stdout c134_X/stderr c134
c134_X:: FRC ;\
-@ echo --- c134 ---  "range checks on INC and DEC"  ;\
   rm -fr c134_X ;\
   mkdir c134_X ;\
   (cd c134_X ; $(COMPILE) ../c134 >stdout ) 1>2 2>c134_X/stderr ;\
   if test -r c134/stdout;\
     then diff c134/stdout c134_X/stdout;\
     else cat c134_X/stdout;\
   fi;\
   if test -r c134/stderr;\
     then diff c134/stderr c134_X/stderr;\
     else cat c134_X/stderr;\
   fi;\
   rm -f c134_X/a.out

all:: c135_X
new_base:: c135_base
scratch:: ; -rm -fr c135_X
c135:: c135_X
c135_base:: c135_X ; @mv c135_X/stdout c135_X/stderr c135
c135_X:: FRC ;\
-@ echo --- c135 ---  "misc. variable initializations"  ;\
   rm -fr c135_X ;\
   mkdir c135_X ;\
   (cd c135_X ; $(COMPILE) ../c135 >stdout ) 1>2 2>c135_X/stderr ;\
   if test -r c135/stdout;\
     then diff c135/stdout c135_X/stdout;\
     else cat c135_X/stdout;\
   fi;\
   if test -r c135/stderr;\
     then diff c135/stderr c135_X/stderr;\
     else cat c135_X/stderr;\
   fi;\
   rm -f c135_X/a.out

all:: c136_X
new_base:: c136_base
scratch:: ; -rm -fr c136_X
c136:: c136_X
c136_base:: c136_X ; @mv c136_X/stdout c136_X/stderr c136
c136_X:: FRC ;\
-@ echo --- c136 ---  "initialized packed field of REF"  ;\
   rm -fr c136_X ;\
   mkdir c136_X ;\
   (cd c136_X ; $(COMPILE) ../c136 >stdout ) 1>2 2>c136_X/stderr ;\
   if test -r c136/stdout;\
     then diff c136/stdout c136_X/stdout;\
     else cat c136_X/stdout;\
   fi;\
   if test -r c136/stderr;\
     then diff c136/stderr c136_X/stderr;\
     else cat c136_X/stderr;\
   fi;\
   rm -f c136_X/a.out

all:: c137_X
new_base:: c137_base
scratch:: ; -rm -fr c137_X
c137:: c137_X
c137_base:: c137_X ; @mv c137_X/stdout c137_X/stderr c137
c137_X:: FRC ;\
-@ echo --- c137 ---  "<*TRACE*> pragma"  ;\
   rm -fr c137_X ;\
   mkdir c137_X ;\
   (cd c137_X ; $(COMPILE) ../c137 >stdout ) 1>2 2>c137_X/stderr ;\
   if test -r c137/stdout;\
     then diff c137/stdout c137_X/stdout;\
     else cat c137_X/stdout;\
   fi;\
   if test -r c137/stderr;\
     then diff c137/stderr c137_X/stderr;\
     else cat c137_X/stderr;\
   fi;\
   rm -f c137_X/a.out

test:: FRC
	@echo $(PF) ctests done

test:: FRC
	@echo $(PF) etests done

scratch:: clean

tidy::
	find . \( -name ",*" -o -name ".,*" -o -name ".emacs_[0-9]*" \
	    -o -name "*~" -o -name core -o -name a.out \) -print | xargs rm -f

clean:: tidy
	find . \( -name "*.o" -o -name "*.io" -o -name "*.ix" \
\
		  -o -name "*.mo" -o -name "*.mx" \) -print | xargs rm -f
	rm -f .makefile .m3path* .PGM_SOURCES .EXPORT* .RSRC_CMD
	rm -f .m3imports*

checkin::     ; vmake -noeval ; vmake -ci < /dev/null
checkout::    ; vmake -co $(PACKAGE) < /dev/null
vestacreate:: ; vmake -co $(PACKAGE).1

FRC: