(UNSET-WATERFALL-PARALLELISM)
(ASSIGN SCRIPT-MODE T)
 T
(SET-LD-PROMPT T STATE)
 T
ACL2 !>>(SET-INHIBITED-SUMMARY-TYPES '(TIME STEPS))
 (TIME STEPS)
ACL2 !>>(SET-INHIBIT-OUTPUT-LST '(PROOF-TREE))
 (PROOF-TREE)
ACL2 !>>(IN-PACKAGE "ACL2")
 "ACL2"
ACL2 !>>(DEFSTOBJ ST$C FLD$C)

Summary
Form:  ( DEFSTOBJ ST$C ...)
Rules: NIL
 ST$C
ACL2 !>>(DEFSTUB STOP NIL NIL)

Summary
Form:  (DEFSTUB STOP ...)
Rules: NIL
 STOP
ACL2 !>>(DEFUN UPDATE-FLD-NIL-GOOD$C (ST$C)
          (DECLARE (XARGS :STOBJS ST$C))
          (UPDATE-FLD$C NIL ST$C))

Since UPDATE-FLD-NIL-GOOD$C is non-recursive, its admission is trivial.
We observe that the type of UPDATE-FLD-NIL-GOOD$C is described by the
theorem (CONSP (UPDATE-FLD-NIL-GOOD$C ST$C)).  We used the :type-prescription
rule UPDATE-FLD$C.

(UPDATE-FLD-NIL-GOOD$C ST$C) => ST$C.

Computing the guard conjecture for UPDATE-FLD-NIL-GOOD$C....

The guard conjecture for UPDATE-FLD-NIL-GOOD$C is trivial to prove.
UPDATE-FLD-NIL-GOOD$C is compliant with Common Lisp.

Summary
Form:  ( DEFUN UPDATE-FLD-NIL-GOOD$C ...)
Rules: ((:TYPE-PRESCRIPTION UPDATE-FLD$C))
 UPDATE-FLD-NIL-GOOD$C
ACL2 !>>(DEFUN UPDATE-FLD-NIL-BAD$C (ST$C)
          (DECLARE (XARGS :STOBJS ST$C))
          (LET ((ST$C (UPDATE-FLD$C T ST$C)))
            (PROG2$ (STOP)
                    (UPDATE-FLD$C NIL ST$C))))

Since UPDATE-FLD-NIL-BAD$C is non-recursive, its admission is trivial.
We observe that the type of UPDATE-FLD-NIL-BAD$C is described by the
theorem (CONSP (UPDATE-FLD-NIL-BAD$C ST$C)).  We used the :type-prescription
rule UPDATE-FLD$C.

(UPDATE-FLD-NIL-BAD$C ST$C) => ST$C.

Computing the guard conjecture for UPDATE-FLD-NIL-BAD$C....

The guard conjecture for UPDATE-FLD-NIL-BAD$C is trivial to prove.
UPDATE-FLD-NIL-BAD$C is compliant with Common Lisp.

Summary
Form:  ( DEFUN UPDATE-FLD-NIL-BAD$C ...)
Rules: ((:TYPE-PRESCRIPTION UPDATE-FLD$C))
 UPDATE-FLD-NIL-BAD$C
ACL2 !>>(DEFUN ST$AP (X)
          (DECLARE (XARGS :GUARD T))
          (EQUAL X NIL))

Since ST$AP is non-recursive, its admission is trivial.  We observe
that the type of ST$AP is described by the theorem 
(OR (EQUAL (ST$AP X) T) (EQUAL (ST$AP X) NIL)).  We used primitive
type reasoning.

Computing the guard conjecture for ST$AP....

The guard conjecture for ST$AP is trivial to prove.  ST$AP is compliant
with Common Lisp.

Summary
Form:  ( DEFUN ST$AP ...)
Rules: ((:FAKE-RUNE-FOR-TYPE-SET NIL))
 ST$AP
ACL2 !>>(DEFUN CREATE-ST$A NIL
          (DECLARE (XARGS :GUARD T))
          NIL)

Since CREATE-ST$A is non-recursive, its admission is trivial.  We observe
that the type of CREATE-ST$A is described by the theorem 
(EQUAL (CREATE-ST$A) NIL).  

Computing the guard conjecture for CREATE-ST$A....

The guard conjecture for CREATE-ST$A is trivial to prove.  CREATE-ST$A
is compliant with Common Lisp.

Summary
Form:  ( DEFUN CREATE-ST$A ...)
Rules: NIL
 CREATE-ST$A
ACL2 !>>(DEFUN FLD$A (ST$A)
          (DECLARE (XARGS :GUARD T))
          ST$A)

Since FLD$A is non-recursive, its admission is trivial.  We observe
that the type of FLD$A is described by the theorem (EQUAL (FLD$A ST$A) ST$A).

Computing the guard conjecture for FLD$A....

The guard conjecture for FLD$A is trivial to prove.  FLD$A is compliant
with Common Lisp.

Summary
Form:  ( DEFUN FLD$A ...)
Rules: NIL
 FLD$A
ACL2 !>>(DEFUN UPDATE-FLD-NIL-BAD$A (ST$A)
          (DECLARE (XARGS :GUARD T) (IGNORE ST$A))
          NIL)

Since UPDATE-FLD-NIL-BAD$A is non-recursive, its admission is trivial.
We observe that the type of UPDATE-FLD-NIL-BAD$A is described by the
theorem (EQUAL (UPDATE-FLD-NIL-BAD$A ST$A) NIL).  

Computing the guard conjecture for UPDATE-FLD-NIL-BAD$A....

The guard conjecture for UPDATE-FLD-NIL-BAD$A is trivial to prove.
UPDATE-FLD-NIL-BAD$A is compliant with Common Lisp.

Summary
Form:  ( DEFUN UPDATE-FLD-NIL-BAD$A ...)
Rules: NIL
 UPDATE-FLD-NIL-BAD$A
ACL2 !>>(DEFUN UPDATE-FLD-NIL-GOOD$A (ST$A)
          (DECLARE (XARGS :GUARD T) (IGNORE ST$A))
          NIL)

Since UPDATE-FLD-NIL-GOOD$A is non-recursive, its admission is trivial.
We observe that the type of UPDATE-FLD-NIL-GOOD$A is described by the
theorem (EQUAL (UPDATE-FLD-NIL-GOOD$A ST$A) NIL).  

Computing the guard conjecture for UPDATE-FLD-NIL-GOOD$A....

The guard conjecture for UPDATE-FLD-NIL-GOOD$A is trivial to prove.
UPDATE-FLD-NIL-GOOD$A is compliant with Common Lisp.

Summary
Form:  ( DEFUN UPDATE-FLD-NIL-GOOD$A ...)
Rules: NIL
 UPDATE-FLD-NIL-GOOD$A
ACL2 !>>(DEFUN-NX ST$CORR (ST$C X)
                  (AND (ST$AP X)
                       (ST$CP ST$C)
                       (EQUAL (FLD$C ST$C) NIL)))

Since ST$CORR is non-recursive, its admission is trivial.  We observe
that the type of ST$CORR is described by the theorem 
(OR (EQUAL (ST$CORR ST$C X) T) (EQUAL (ST$CORR ST$C X) NIL)).  We used
primitive type reasoning.

Summary
Form:  ( DEFUN ST$CORR ...)
Rules: ((:FAKE-RUNE-FOR-TYPE-SET NIL))
 (:DEFUN-NX ST$CORR)
ACL2 !>>(IN-THEORY (DISABLE (ST$CORR)))

Summary
Form:  ( IN-THEORY (DISABLE ...))
Rules: NIL
 :CURRENT-THEORY-UPDATED
ACL2 !>>(DEFTHM CREATE-ST{CORRESPONDENCE}
          (ST$CORR (CREATE-ST$C) (CREATE-ST$A))
          :RULE-CLASSES NIL)

Q.E.D.

Summary
Form:  ( DEFTHM CREATE-ST{CORRESPONDENCE} ...)
Rules: ((:DEFINITION CREATE-ST$C)
        (:DEFINITION ST$CORR)
        (:EXECUTABLE-COUNTERPART CREATE-ST$A)
        (:EXECUTABLE-COUNTERPART EQUAL)
        (:EXECUTABLE-COUNTERPART FLD$C)
        (:EXECUTABLE-COUNTERPART IF)
        (:EXECUTABLE-COUNTERPART ST$AP)
        (:EXECUTABLE-COUNTERPART ST$CP))
 CREATE-ST{CORRESPONDENCE}
ACL2 !>>(DEFTHM CREATE-ST{PRESERVED}
          (ST$AP (CREATE-ST$A))
          :RULE-CLASSES NIL)

Q.E.D.

Summary
Form:  ( DEFTHM CREATE-ST{PRESERVED} ...)
Rules: ((:EXECUTABLE-COUNTERPART CREATE-ST$A)
        (:EXECUTABLE-COUNTERPART ST$AP))
 CREATE-ST{PRESERVED}
ACL2 !>>(DEFTHM FLD{CORRESPONDENCE}
          (IMPLIES (ST$CORR ST$C ST)
                   (EQUAL (FLD$C ST$C) (FLD$A ST)))
          :RULE-CLASSES NIL)

Q.E.D.

Summary
Form:  ( DEFTHM FLD{CORRESPONDENCE} ...)
Rules: ((:DEFINITION FLD$A)
        (:DEFINITION FLD$C)
        (:DEFINITION ST$AP)
        (:DEFINITION ST$CORR)
        (:DEFINITION ST$CP)
        (:EXECUTABLE-COUNTERPART TAU-SYSTEM))
 FLD{CORRESPONDENCE}
ACL2 !>>(DEFTHM UPDATE-FLD-NIL-GOOD{CORRESPONDENCE}
          (IMPLIES (ST$CORR ST$C ST)
                   (ST$CORR (UPDATE-FLD-NIL-GOOD$C ST$C)
                            (UPDATE-FLD-NIL-GOOD$A ST)))
          :RULE-CLASSES NIL)
Goal'
Goal''

Q.E.D.

Summary
Form:  ( DEFTHM UPDATE-FLD-NIL-GOOD{CORRESPONDENCE} ...)
Rules: ((:DEFINITION FLD$C)
        (:DEFINITION LEN)
        (:DEFINITION LENGTH)
        (:DEFINITION NTH)
        (:DEFINITION ST$AP)
        (:DEFINITION ST$CORR)
        (:DEFINITION ST$CP)
        (:DEFINITION TRUE-LISTP)
        (:DEFINITION UPDATE-FLD$C)
        (:DEFINITION UPDATE-FLD-NIL-GOOD$A)
        (:DEFINITION UPDATE-FLD-NIL-GOOD$C)
        (:DEFINITION UPDATE-NTH)
        (:EXECUTABLE-COUNTERPART BINARY-+)
        (:EXECUTABLE-COUNTERPART CAR)
        (:EXECUTABLE-COUNTERPART CDR)
        (:EXECUTABLE-COUNTERPART CONSP)
        (:EXECUTABLE-COUNTERPART EQUAL)
        (:EXECUTABLE-COUNTERPART FLD$C)
        (:EXECUTABLE-COUNTERPART LEN)
        (:EXECUTABLE-COUNTERPART NOT)
        (:EXECUTABLE-COUNTERPART ST$AP)
        (:EXECUTABLE-COUNTERPART ST$CP)
        (:EXECUTABLE-COUNTERPART UPDATE-NTH)
        (:EXECUTABLE-COUNTERPART ZP)
        (:FAKE-RUNE-FOR-TYPE-SET NIL)
        (:REWRITE CDR-CONS)
        (:REWRITE NTH-0-CONS))
 UPDATE-FLD-NIL-GOOD{CORRESPONDENCE}
ACL2 !>>(DEFTHM UPDATE-FLD-NIL-GOOD{PRESERVED}
          (IMPLIES (ST$AP ST)
                   (ST$AP (UPDATE-FLD-NIL-GOOD$A ST)))
          :RULE-CLASSES NIL)

Q.E.D.

Summary
Form:  ( DEFTHM UPDATE-FLD-NIL-GOOD{PRESERVED} ...)
Rules: ((:DEFINITION ST$AP)
        (:DEFINITION UPDATE-FLD-NIL-GOOD$A)
        (:EXECUTABLE-COUNTERPART IF)
        (:EXECUTABLE-COUNTERPART ST$AP))
 UPDATE-FLD-NIL-GOOD{PRESERVED}
ACL2 !>>(DEFTHM UPDATE-FLD-NIL-BAD{CORRESPONDENCE}
          (IMPLIES (ST$CORR ST$C ST)
                   (ST$CORR (UPDATE-FLD-NIL-BAD$C ST$C)
                            (UPDATE-FLD-NIL-BAD$A ST)))
          :RULE-CLASSES NIL)
Goal'
Goal''

Q.E.D.

Summary
Form:  ( DEFTHM UPDATE-FLD-NIL-BAD{CORRESPONDENCE} ...)
Rules: ((:DEFINITION FLD$C)
        (:DEFINITION LEN)
        (:DEFINITION LENGTH)
        (:DEFINITION NTH)
        (:DEFINITION ST$AP)
        (:DEFINITION ST$CORR)
        (:DEFINITION ST$CP)
        (:DEFINITION TRUE-LISTP)
        (:DEFINITION UPDATE-FLD$C)
        (:DEFINITION UPDATE-FLD-NIL-BAD$A)
        (:DEFINITION UPDATE-FLD-NIL-BAD$C)
        (:DEFINITION UPDATE-NTH)
        (:EXECUTABLE-COUNTERPART BINARY-+)
        (:EXECUTABLE-COUNTERPART CAR)
        (:EXECUTABLE-COUNTERPART CDR)
        (:EXECUTABLE-COUNTERPART CONSP)
        (:EXECUTABLE-COUNTERPART EQUAL)
        (:EXECUTABLE-COUNTERPART FLD$C)
        (:EXECUTABLE-COUNTERPART LEN)
        (:EXECUTABLE-COUNTERPART NOT)
        (:EXECUTABLE-COUNTERPART ST$AP)
        (:EXECUTABLE-COUNTERPART ST$CP)
        (:EXECUTABLE-COUNTERPART UPDATE-FLD$C)
        (:EXECUTABLE-COUNTERPART UPDATE-NTH)
        (:EXECUTABLE-COUNTERPART ZP)
        (:FAKE-RUNE-FOR-TYPE-SET NIL)
        (:REWRITE CDR-CONS)
        (:REWRITE NTH-0-CONS))
 UPDATE-FLD-NIL-BAD{CORRESPONDENCE}
ACL2 !>>(DEFTHM UPDATE-FLD-NIL-BAD{PRESERVED}
          (IMPLIES (ST$AP ST)
                   (ST$AP (UPDATE-FLD-NIL-BAD$A ST)))
          :RULE-CLASSES NIL)

Q.E.D.

Summary
Form:  ( DEFTHM UPDATE-FLD-NIL-BAD{PRESERVED} ...)
Rules: ((:DEFINITION ST$AP)
        (:DEFINITION UPDATE-FLD-NIL-BAD$A)
        (:EXECUTABLE-COUNTERPART IF)
        (:EXECUTABLE-COUNTERPART ST$AP))
 UPDATE-FLD-NIL-BAD{PRESERVED}
ACL2 !>>(DEFABSSTOBJ ST
          :EXPORTS ((FLD)
                    (UPDATE-FLD-NIL-GOOD)
                    (UPDATE-FLD-NIL-BAD :PROTECT T)))

Summary
Form:  ( DEFABSSTOBJ ST ...)
Rules: NIL
 ST
ACL2 !>>(MAKE-EVENT (MV-LET (ERP VAL STATE)
                            (TRANS-EVAL '(UPDATE-FLD-NIL-BAD ST)
                                        'TOP
                                        STATE T)
                      (DECLARE (IGNORE ERP VAL))
                      (VALUE '(VALUE-TRIPLE :IRRELEVANT-VALUE))))

ACL2 Warning [User-stobjs-modified] in TOP:  A call of the ACL2 evaluator
on the term (UPDATE-FLD-NIL-BAD ST) may have modified the user stobj
ST.  See :DOC user-stobjs-modified-warnings.



ACL2 Error [Evaluation] in TOP:  ACL2 cannot ev the call of non-executable
function STOP on argument list:

NIL

To debug see :DOC print-gv, see :DOC trace, and see :DOC wet.


Summary
Form:  ( MAKE-EVENT (MV-LET ...))
Rules: NIL
Warnings:  User-stobjs-modified
 :IRRELEVANT-VALUE


ACL2 Error in CHK-ABSSTOBJ-INVARIANTS:  Possible invariance violation
for an abstract stobj!
**PROCEED AT YOUR OWN RISK.**
To proceed, evaluate the following form.
:CONTINUE-FROM-ILLEGAL-STATE
See :DOC set-absstobj-debug.


[Illegal-State] >>(+ 3 4)


ACL2 Error in LD-FILTER-COMMAND:  You are still in an illegal state!
See :DOC illegal-state.  You can submit the form
:CONTINUE-FROM-ILLEGAL-STATE
to continue -- AT YOUR OWN RISK.

[Illegal-State] >>:CONTINUE-FROM-ILLEGAL-STATE
 :CONTINUING
ACL2 !>>(+ 3 4)
7
ACL2 !>>(ASSERT-EVENT (EQUAL (FLD ST) T))
 :PASSED
ACL2 !>>(MAKE-EVENT (MV-LET (ERP VAL STATE)
                            (TRANS-EVAL '(UPDATE-FLD-NIL-GOOD ST)
                                        'TOP
                                        STATE T)
                      (DECLARE (IGNORE ERP VAL))
                      (VALUE '(VALUE-TRIPLE :IRRELEVANT-VALUE))))

ACL2 Warning [User-stobjs-modified] in TOP:  A call of the ACL2 evaluator
on the term (UPDATE-FLD-NIL-GOOD ST) may have modified the user stobj
ST.  See :DOC user-stobjs-modified-warnings.


Summary
Form:  ( MAKE-EVENT (MV-LET ...))
Rules: NIL
Warnings:  User-stobjs-modified
 :IRRELEVANT-VALUE
ACL2 !>>(ASSERT-EVENT (EQUAL (FLD ST) NIL))
 :PASSED
ACL2 !>>(SET-ABSSTOBJ-DEBUG T)
 T
ACL2 !>>(MAKE-EVENT (MV-LET (ERP VAL STATE)
                            (TRANS-EVAL '(UPDATE-FLD-NIL-BAD ST)
                                        'TOP
                                        STATE T)
                      (DECLARE (IGNORE ERP VAL))
                      (VALUE '(VALUE-TRIPLE :IRRELEVANT-VALUE))))

ACL2 Warning [User-stobjs-modified] in TOP:  A call of the ACL2 evaluator
on the term (UPDATE-FLD-NIL-BAD ST) may have modified the user stobj
ST.  See :DOC user-stobjs-modified-warnings.



ACL2 Error [Evaluation] in TOP:  ACL2 cannot ev the call of non-executable
function STOP on argument list:

NIL

To debug see :DOC print-gv, see :DOC trace, and see :DOC wet.


Summary
Form:  ( MAKE-EVENT (MV-LET ...))
Rules: NIL
Warnings:  User-stobjs-modified
 :IRRELEVANT-VALUE


ACL2 Error in CHK-ABSSTOBJ-INVARIANTS:  Possible invariance violation
for an abstract stobj!
**PROCEED AT YOUR OWN RISK.**
To proceed, evaluate the following form.
:CONTINUE-FROM-ILLEGAL-STATE
See :DOC set-absstobj-debug.
Evaluation was aborted under a call of abstract stobj export 
UPDATE-FLD-NIL-BAD.

[Illegal-State] >>(CONTINUE-FROM-ILLEGAL-STATE)
 :CONTINUING
ACL2 !>>(WITH-OUTPUT :OFF
                     :ALL (DEFEVALUATOR EVL EVL-LIST ((EQUAL X Y))))
Goal'
Goal''
Subgoal 3
Subgoal 3'
Subgoal 2
Subgoal 2'
Subgoal 1
Subgoal 1'
Subgoal *1/2
Subgoal *1/1
Subgoal *1/2
Subgoal *1/1
Subgoal 2
Subgoal 1
Subgoal 2
Subgoal 1
Goal'
Subgoal 2
Subgoal 1
 (EVL EVL-LIST)
ACL2 !>>(DEFUN SIMPLE-CL-PROC (CL TERM ST)
          (DECLARE (XARGS :STOBJS ST)
                   (IGNORE TERM))
          (LET ((ST (UPDATE-FLD-NIL-BAD ST)))
            (MV NIL (LIST CL) ST)))

Since SIMPLE-CL-PROC is non-recursive, its admission is trivial.  We
observe that the type of SIMPLE-CL-PROC is described by the theorem
(AND (CONSP (SIMPLE-CL-PROC CL TERM ST))
     (TRUE-LISTP (SIMPLE-CL-PROC CL TERM ST))).
We used primitive type reasoning and the :type-prescription rule 
UPDATE-FLD-NIL-BAD.

(SIMPLE-CL-PROC * * ST) => (MV * * ST).

Computing the guard conjecture for SIMPLE-CL-PROC....

The guard conjecture for SIMPLE-CL-PROC is trivial to prove.  SIMPLE-CL-PROC
is compliant with Common Lisp.

Summary
Form:  ( DEFUN SIMPLE-CL-PROC ...)
Rules: ((:FAKE-RUNE-FOR-TYPE-SET NIL)
        (:TYPE-PRESCRIPTION UPDATE-FLD-NIL-BAD))
 SIMPLE-CL-PROC
ACL2 !>>(DEFTHM CORRECTNESS-OF-SIMPLE-CL-PROC
         (IMPLIES
          (AND
           (PSEUDO-TERM-LISTP CL)
           (ALISTP A)
           (EVL
               (CONJOIN-CLAUSES (CLAUSES-RESULT (SIMPLE-CL-PROC CL TERM ST)))
               A))
          (EVL (DISJOIN CL) A))
         :RULE-CLASSES :CLAUSE-PROCESSOR)
Goal'

Q.E.D.

Summary
Form:  ( DEFTHM CORRECTNESS-OF-SIMPLE-CL-PROC ...)
Rules: ((:DEFINITION CLAUSES-RESULT)
        (:DEFINITION CONJOIN)
        (:DEFINITION CONJOIN-CLAUSES)
        (:DEFINITION DISJOIN-LST)
        (:DEFINITION SIMPLE-CL-PROC)
        (:EXECUTABLE-COUNTERPART CONSP)
        (:EXECUTABLE-COUNTERPART DISJOIN-LST)
        (:FAKE-RUNE-FOR-TYPE-SET NIL)
        (:REWRITE CAR-CONS)
        (:REWRITE CDR-CONS))
 CORRECTNESS-OF-SIMPLE-CL-PROC
ACL2 !>>(INCLUDE-BOOK "std/testing/must-fail"
                      :DIR :SYSTEM)

Summary
Form:  ( INCLUDE-BOOK "std/testing/must-fail" ...)
Rules: NIL
 (:SYSTEM . "std/testing/must-fail.lisp")
ACL2 !>>(MUST-FAIL (THM (EQUAL X X)
                        :HINTS (("Goal" :CLAUSE-PROCESSOR SIMPLE-CL-PROC))))

Summary
Form:  ( MAKE-EVENT (QUOTE ...) ...)
Rules: NIL
 T


ACL2 Error in CHK-ABSSTOBJ-INVARIANTS:  Possible invariance violation
for an abstract stobj!
**PROCEED AT YOUR OWN RISK.**
To proceed, evaluate the following form.
:CONTINUE-FROM-ILLEGAL-STATE
See :DOC set-absstobj-debug.
Evaluation was aborted under a call of abstract stobj export 
UPDATE-FLD-NIL-BAD.

[Illegal-State] >>(CONTINUE-FROM-ILLEGAL-STATE)
 :CONTINUING
ACL2 !>>(WITH-OUTPUT
         :OFF (ERROR SUMMARY)
         (THM
             (EQUAL X X)
             :HINTS (("Goal" :INSTRUCTIONS ((CL-PROC :FUNCTION SIMPLE-CL-PROC
                                                     :HINT NIL))))))


ACL2 Error in CHK-ABSSTOBJ-INVARIANTS:  Possible invariance violation
for an abstract stobj!
**PROCEED AT YOUR OWN RISK.**
To proceed, evaluate the following form.
:CONTINUE-FROM-ILLEGAL-STATE
See :DOC set-absstobj-debug.
Evaluation was aborted under a call of abstract stobj export 
UPDATE-FLD-NIL-BAD.

[Illegal-State] >>(CONTINUE-FROM-ILLEGAL-STATE)
 :CONTINUING
ACL2 !>>(DEFTTAG :BOGUS-CERT)
 :BOGUS-CERT
ACL2 !>>(REMOVE-UNTOUCHABLE ILLEGAL-TO-CERTIFY-MESSAGE NIL)

Summary
Form:  ( REMOVE-UNTOUCHABLE ILLEGAL-TO-CERTIFY-MESSAGE NIL)
Rules: NIL
 ILLEGAL-TO-CERTIFY-MESSAGE
ACL2 !>>(MAKE-EVENT (PPROGN (F-PUT-GLOBAL 'ILLEGAL-TO-CERTIFY-MESSAGE
                                          NIL STATE)
                            (VALUE '(VALUE-TRIPLE :CERTIFICATION-MADE-OK))))

Summary
Form:  ( MAKE-EVENT (PPROGN ...))
Rules: NIL
 :CERTIFICATION-MADE-OK
ACL2 !>>(DEFTTAG NIL)
 NIL
ACL2 !>>(VALUE-TRIPLE "Completed")
 "Completed"
ACL2 !>>Bye.
